示例#1
0
文件: i8x9x.c 项目: opicron/mame
UINT16 i8x9x_device::io_r16(UINT8 adr)
{
	switch(adr) {
	case 0x00:
		return 0x0000;
	case 0x02:
		return ad_result;
	case 0x04:
		logerror("%s: read hsi time (%04x)\n", tag(), PPC);
		return 0x0000;
	case 0x0a:
		return timer_value(1, get_cycle());
	case 0x0c:
		logerror("%s: read timer2 (%04x)\n", tag(), PPC);
		return timer_value(2, get_cycle());
	default:
		return io_r8(adr) | (io_r8(adr+1) << 8);
	}
}
示例#2
0
static void
return_addr_stack(struct prog_arg *p,
                  struct thread_data *a)
{
    int max_depth = 32;
    int md, li, n = p->nloop;

    time_init();

    for (md=1; md<max_depth; md++) {
        long long tb = get_cycle(), te;

        for (li=0; li<n; li++) {
            recfuncs[md](1);
        }

        te = get_cycle();

        printf("depth %d: %f\n", md, (te-tb)/(double)(n*md));
    }

    time_end();
}
示例#3
0
文件: i8x9x.c 项目: opicron/mame
void i8x9x_device::commit_hso_cam()
{
	for(int i=0; i<8; i++)
		if(!hso_info[i].active) {
			if(hso_command != 0x18 && hso_command != 0x19)
				logerror("%s: hso cam %02x %04x in slot %d (%04x)\n", tag(), hso_command, hso_time, i, PPC);
			hso_info[i].active = true;
			hso_info[i].command = hso_command;
			hso_info[i].time = hso_time;
			internal_update(get_cycle());
			return;
		}
	hso_cam_hold.active = true;
	hso_cam_hold.command = hso_command;
	hso_cam_hold.time = hso_time;
}
示例#4
0
/** Initialize CPUs
 *
 * Initialize kernel CPUs support.
 *
 */
void cpu_init(void) {
#ifdef CONFIG_SMP
	if (config.cpu_active == 1) {
#endif /* CONFIG_SMP */
		
		cpus = (cpu_t *) malloc(sizeof(cpu_t) * config.cpu_count,
		    FRAME_ATOMIC);
		if (!cpus)
			panic("Cannot allocate CPU structures.");
		
		/* Initialize everything */
		memsetb(cpus, sizeof(cpu_t) * config.cpu_count, 0);
		
		size_t i;
		for (i = 0; i < config.cpu_count; i++) {
			cpus[i].stack = (uint8_t *) frame_alloc(STACK_FRAMES,
			    FRAME_LOWMEM | FRAME_KA | FRAME_ATOMIC);
			cpus[i].id = i;
			
			irq_spinlock_initialize(&cpus[i].lock, "cpus[].lock");
			
			unsigned int j;
			for (j = 0; j < RQ_COUNT; j++) {
				irq_spinlock_initialize(&cpus[i].rq[j].lock, "cpus[].rq[].lock");
				list_initialize(&cpus[i].rq[j].rq);
			}
		}
		
#ifdef CONFIG_SMP
	}
#endif /* CONFIG_SMP */
	
	CPU = &cpus[config.cpu_active - 1];
	
	CPU->active = true;
	CPU->tlb_active = true;
	
	CPU->idle = false;
	CPU->last_cycle = get_cycle();
	CPU->idle_cycles = 0;
	CPU->busy_cycles = 0;
	
	cpu_identify();
	cpu_arch_init();
}
示例#5
0
void test_nong0() 
{
	const int CYCLE = 10;
	const int CONTACT_INHIB_TICKS = 10;
	char_array * id_temp;
	//initialise();
	
	calcium_level = 0.1;
	
	// add agent with 1 bonds in x-y plane, no z bonds, not on edge of substrate
	id_temp = init_char_array();
	add_char(id_temp, '1');
	add_keratinocyte_agent(id_temp, K_TYPE_STEM, 10, 10, 0, 0, 0, 0, 1, 0, 0, CYCLE, 0, CONTACT_INHIB_TICKS, 0, 0, 0, 0);	
	current_xmachine = *p_xmachine;

	cycle();	
	
	CU_ASSERT_EQUAL(get_cycle(), CYCLE+1); 
	CU_ASSERT_EQUAL(get_contact_inhibited_ticks(), 0);
}
示例#6
0
文件: gr_bary.c 项目: fd00/genlog
/* compute_bary_positions - This function computes all positions of the 
                            nodes in baricentric way. It finds a cycle in
			    the graph of a given number. It places the cycle
			    in a circle and compute the rest of the nodes in
			    baricentric way inside of the circle. 
         inputs  
                 gf - Graph Structure
		 cycle_len - Length of the Cycle
         returns
                  0 - No problem in computing circular positions of nodes
		  RESIZE_WINDOW - The Drawing Area was resized. 
		  WINDOW_FULL - The window can not hold more nodes.
		  NO_CYCLE - There is not cycle of cycle_len in the graph.
		  MEMORY_MATRIX - There is not memory for the matrix.
         side effects
                  The hash table of vertices changes completely. 
         notes
                 If a vertex can not be located in the circle, the vertex 
		 is placed in a empty location of the window. If two or
		 more vertices are in the same location, it finds a near 
		 spot and place all vertices in different positions.
*/
int 
compute_bary_positions(GraphFrame *gf, int cycle_len)
{
  int mes = 0;
  enumerate_vertices(gf);
  reset_mark_pick_vertices(gf);
  reset_level_vertices(gf);

  if(!gf->the_cycle)
    gf->the_cycle = init_linked_list();
  if(!gf->list_visited_vertex)
    gf->list_visited_vertex = init_linked_list();
  if(!gf->the_rest)
    gf->the_rest = init_linked_list();

  get_cycle(gf, cycle_len);
  /*printing_linked_list(gf->the_cycle);*/
  if(!is_empty_list(gf->the_cycle))
    {
      Delete_hash_table(gf->HV);
      
      circularize(gf,gf->the_cycle, cycle_len);
      get_rest(gf);
      /*printing_linked_list(gf->the_rest);*/
      if(!is_empty_list(gf->the_rest))
	mes = layout_rest(gf, gf->the_rest, gf->count_vertex-cycle_len);

    }
  else
    mes = NO_CYCLE;

  Delete_all_list(gf->the_cycle);
  Delete_all_list(gf->list_visited_vertex);
  Delete_all_list(gf->the_rest);
  gf->the_cycle = init_linked_list();
  gf->list_visited_vertex = init_linked_list();
  gf->the_rest = init_linked_list();
  return mes;
}
示例#7
0
文件: i8x9x.c 项目: opicron/mame
UINT8 i8x9x_device::io_r8(UINT8 adr)
{
	switch(adr) {
	case 0x00:
		return 0x00;
	case 0x01:
		return 0x00;
	case 0x02:
		return ad_result;
	case 0x03:
		return ad_result >> 8;
	case 0x04:
		logerror("%s: read hsi time l (%04x)\n", tag(), PPC);
		return 0x00;
	case 0x05:
		logerror("%s: read hsi time h (%04x)\n", tag(), PPC);
		return 0x00;
	case 0x06:
		logerror("%s: read hsi status (%04x)\n", tag(), PPC);
		return 0x00;
	case 0x07:
		logerror("%s: read sbuf %02x (%04x)\n", tag(), sbuf, PPC);
		return sbuf;
	case 0x08:
		return PSW;
	case 0x09:
		logerror("%s: read int pending (%04x)\n", tag(), PPC);
		return pending_irq;
	case 0x0a:
		logerror("%s: read timer1 l (%04x)\n", tag(), PPC);
		return timer_value(1, get_cycle());
	case 0x0b:
		logerror("%s: read timer1 h (%04x)\n", tag(), PPC);
		return timer_value(1, get_cycle()) >> 8;
	case 0x0c:
		logerror("%s: read timer2 l (%04x)\n", tag(), PPC);
		return timer_value(2, get_cycle());
	case 0x0d:
		logerror("%s: read timer2 h (%04x)\n", tag(), PPC);
		return timer_value(2, get_cycle()) >> 8;
	case 0x0e: {
		static int last = -1;
		if(io->read_word(P0*2) != last) {
			last = io->read_word(P0*2);
			logerror("%s: read p0 %02x\n", tag(), io->read_word(P0*2));
		}
		return io->read_word(P0*2);
	}
	case 0x0f:
		return io->read_word(P1*2);
	case 0x10:
		return io->read_word(P2*2);
	case 0x11: {
		UINT8 res = sp_stat;
		sp_stat &= 0x80;
		logerror("%s: read sp stat %02x (%04x)\n", tag(), res, PPC);
		return res;
	}
	case 0x15:
		logerror("%s: read ios 0 %02x (%04x)\n", tag(), ios0, PPC);
		return ios0;
	case 0x16: {
		UINT8 res = ios1;
		ios1 = ios1 & 0xc0;
		return res;
	}
	default:
		logerror("%s: io_r8 %02x (%04x)\n", tag(), adr, PPC);
		return 0x00;
	}
}
示例#8
0
文件: i8x9x.c 项目: opicron/mame
void i8x9x_device::io_w8(UINT8 adr, UINT8 data)
{
	switch(adr) {
	case 0x02:
		ad_command = data;
		if(ad_command & 8)
			ad_start(get_cycle());
		break;
	case 0x03:
		logerror("%s: hsi_mode %02x (%04x)\n", tag(), data, PPC);
		break;
	case 0x04:
		hso_time = (hso_time & 0xff00) | data;
		break;
	case 0x05:
		hso_time = (hso_time & 0x00ff) | (data << 8);
		commit_hso_cam();
		break;
	case 0x06:
		hso_command = data;
		break;
	case 0x07:
		logerror("%s: sbuf %02x (%04x)\n", tag(), data, PPC);
		serial_send(data);
		break;
	case 0x08:
		PSW = (PSW & 0xff00) | data;
		check_irq();
		break;
	case 0x09:
		pending_irq = data;
		logerror("%s: int_pending %02x (%04x)\n", tag(), data, PPC);
		break;
	case 0x0a:
		logerror("%s: watchdog %02x (%04x)\n", tag(), data, PPC);
		break;
	case 0x0e:
		logerror("%s: baud rate %02x (%04x)\n", tag(), data, PPC);
		break;
	case 0x0f:
		logerror("%s: io port 1 %02x (%04x)\n", tag(), data, PPC);
		io->write_word(P1*2, data);
		break;
	case 0x10:
		logerror("%s: io port 2 %02x (%04x)\n", tag(), data, PPC);
		io->write_word(P2*2, data);
		break;
	case 0x11:
		logerror("%s: sp con %02x (%04x)\n", tag(), data, PPC);
		break;
	case 0x15:
		logerror("%s: ioc0 %02x (%04x)\n", tag(), data, PPC);
		ioc0 = data;
		break;
	case 0x16:
		logerror("%s: ioc1 %02x (%04x)\n", tag(), data, PPC);
		ioc1 = data;
		break;
	case 0x17:
		logerror("%s: pwm control %02x (%04x)\n", tag(), data, PPC);
		break;
	}
	return;
}
示例#9
0
文件: i8x9x.c 项目: opicron/mame
void i8x9x_device::serial_send(UINT8 data)
{
	serial_send_buf = data;
	serial_send_timer = get_cycle() + 9600;
}
示例#10
0
static void
mem_reorder(struct prog_arg *pa, struct thread_data *ta)
{
    int n = pa->nloop;
    int i;
    long long tb;
    long long te;
    long long t1, t2;
    long long niter = 512;
    volatile unsigned int *ptr0 = (unsigned int*)pa->mem1;
    unsigned int *ptr1 = (unsigned int*)pa->mem1;

    asm volatile ("":"+r"(ptr0),"+r"(ptr1));

    ptr1 ++;

    time_init();

    tb = get_cycle();

    int sum0 = 0;
    for (i=0; i<n; i++) {
        long long bi = 0;
        int j;

        for (j=0; j<niter; j+=4) {
            ptr1[(j*4+0)*2] = 0;
            ptr0[(j*4+0)*2];
            ptr1[(j*4+1)*2] = 0;
            ptr0[(j*4+1)*2];
            ptr1[(j*4+2)*2] = 0;
            ptr0[(j*4+2)*2];
            ptr1[(j*4+3)*2] = 0;
            ptr0[(j*4+3)*2];
        }
    }
    te = get_cycle();

    t1 = te-tb;


    tb = get_cycle();

    for (i=0; i<n; i++) {
        long long bi = 0;
        int j;

        for (j=0; j<niter; j+=4) {
            ptr1[(j*4+0)*2] = 0;
            ptr1[(j*4+1)*2] = 0;
            ptr1[(j*4+2)*2] = 0;
            ptr1[(j*4+3)*2] = 0;

            ptr0[(j*4+0)*2];
            ptr0[(j*4+1)*2];
            ptr0[(j*4+2)*2];
            ptr0[(j*4+3)*2];
        }
    }
    te = get_cycle();

    t2 = te-tb;


    time_end();

    double inst_total = n * niter * 2.0;

    printf("IPC=%f/%f sum=%d\n",
           (double)inst_total/(double)(t1),
           (double)inst_total/(double)(t2),
           sum0);
}
示例#11
0
int cycle()
{
	xmachine_memory_keratinocyte * xmemory = current_xmachine->xmachine_keratinocyte;
	
	char_array id_temp;
	char buffer[10];
	
		/* find number of contacts/bonds*/
	int contacts = get_num_xy_bonds() + get_num_z_bonds();

	/* touching a wall counts as two contacts*/
	if (get_x() == 0 || get_x() == substrate_width) {
		contacts += 2;
	}
	if (get_y() == 0 || get_y() == substrate_width) {
		contacts += 2;
	}

	if (contacts <= get_max_num_bonds(calcium_level)) { 
		/* cell comes out of G0*/
		set_cycle(get_cycle()+1);
		set_contact_inhibited_ticks(0);
	} else {
		/* cell enters G0*/
		set_contact_inhibited_ticks(get_contact_inhibited_ticks()+1);
	}

	/* check to see if enough time has elapsed as to whether cell can divide*/
	if (divide(get_type(), get_cycle())) {
		
		int new_cycle 				 = start_new_cycle_postion();
		double new_x                 = get_new_coord(get_x(), FALSE);
		double new_y                 = get_new_coord(get_y(), FALSE);
		double new_z                 = get_z();
		double new_diff_noise_factor = 0.9 + (rnd()*0.2);	
		double new_dir               = rnd() * 2 * PI;
		double new_motility          = (0.5 + (rnd() * 0.5)) * get_new_motility(get_type(), calcium_level);
		
		last_agent_id ++; 			 	/* generate a new ID*/
		
		if (can_stratify(get_type(), calcium_level) && get_num_xy_bonds() >= MAX_NUM_LATERAL_BONDS) {
			new_z = get_new_coord(get_z(), TRUE);
		}
		xmemory->cycle = start_new_cycle_postion();
		
		init_char_array(&id_temp);
		copy_char_array(&ID_CHAR, &id_temp);
		add_char(&id_temp, '.');
		sprintf(buffer, "%d", SPLITS);
		add_char(&id_temp, buffer[0]);
		
		printf("new cell: %s\n", id_temp.array);
		
		add_keratinocyte_agent(
			/*get_id()+1,*/
			ID,
			&id_temp,
			/*last_agent_id,      		 id*/
			0,							/* splits*/
			get_type(),      			/* type*/
			new_x, 						/* x*/
			new_y, 						/* y*/
			new_z,						/* z*/
			0,                			/* force_x*/
			0,				  			/* force_y*/
			0,							/* force_z*/
			0,				  			/* num_xy_bonds*/
			0,				  			/* num_z_bonds*/
			0,                			/* num_stem_bonds*/
			new_cycle,        			/* cycle*/
			new_diff_noise_factor,		/* diff_noise_factor*/
			0,                  		/* dead_ticks*/
			0,  	            		/* contact_inhibited_ticks*/
			new_motility,  				/* motility*/
			new_dir,					/* dir*/
			get_range()					/* range */
			);
		
		xmemory->splits++;
		
		free_char_array(&id_temp);
	}
	return 0;
}