void server_procedure(struct command_line_args *object) { struct packet *p; My402ListElem *elem = NULL; struct timespec tim; double time; long time_diff_in_nsec; int i = 0; while( i < object->no_of_packets && !EndServerThread) { pthread_mutex_lock(&token_bucket); while(My402ListEmpty(&Q2PacketList)&&!EndServerThread) pthread_cond_wait(&is_q2_empty,&token_bucket); if(EndServerThread == 1) { pthread_mutex_unlock(&token_bucket); break; } elem = My402ListFirst(&Q2PacketList); if(elem == NULL) { pthread_mutex_unlock(&token_bucket); break; } p = (struct packet *)elem->obj; My402ListUnlink(&Q2PacketList, elem); pthread_mutex_unlock(&token_bucket); gettimeofday(&(p->Q2leaves), NULL); time = (TIME_IN_USEC(p->Q2leaves) - TIME_IN_USEC(GlobalStartTime))/1000; p->time_in_Q2 = (TIME_IN_USEC(p->Q2leaves) - TIME_IN_USEC(p->Q2timestamp))/1000; LOG(stdout, "%012.3fms: p%d begin service at S, time in Q2 = %.3fms\n",time,p->packet_id,p->time_in_Q2); time_diff_in_nsec = (long)((((p->precise_packet_service_time)/1000) - (p->service_time/1000))*1000000000L); tim.tv_sec = (p->service_time)/1000; tim.tv_nsec = time_diff_in_nsec; nanosleep(&tim, NULL); gettimeofday(&(p->Leaves_server), NULL); time = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(GlobalStartTime))/1000; p->time_in_system = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(p->Arrival_timestamp))/1000; p->precise_packet_service_time = (TIME_IN_USEC(p->Leaves_server) - TIME_IN_USEC(p->Q2leaves))/1000; LOG(stdout, "%012.3fms: p%d departs from S, service time = %.3fms, time in system = %.3fms\n",time,p->packet_id,p->precise_packet_service_time,p->time_in_system); completed_packets ++; calculate_stats(p); if((packet_count == object->no_of_packets) &&(completed_packets == (packet_count-discarded_packets)) && My402ListEmpty(&Q2PacketList)) { EndServerThread = 1; pthread_cond_signal(&is_q2_empty); } i++; } pthread_exit(NULL); }
int atarisys2_interrupt (void) { int i; /* set the 32V timer */ timer_set (TIME_IN_USEC (Machine->drv->vblank_duration), 0, atarisys2_32v_interrupt); timer_set (TIME_IN_USEC (Machine->drv->vblank_duration), 0, atarisys2_video_update); /* update the pedals once per frame */ for (i = 0; i < pedal_count; i++) { if (readinputport (3 + i) & 0x80) { pedal_value[i] += 64; if (pedal_value[i] > 0xff) pedal_value[i] = 0xff; } else { pedal_value[i] -= 64; if (pedal_value[i] < 0) pedal_value[i] = 0; } } /* VBLANK is 3 */ if (!irq_hold3 && (READ_WORD (&atarisys2_interrupt_enable[0]) & 8)) { irq_hold3 = 1; return 3; } else return ignore_interrupt (); }
static WRITE16_HANDLER( hypr_subcpu_control_w ) { int pc = activecpu_get_pc(); if (data & 0x01) { if (!subcpu_resetline) { if (pc != 0x95f2) { cpunum_set_input_line(1, INPUT_LINE_RESET, ASSERT_LINE); subcpu_resetline = 1; } else { cpunum_set_input_line(1, INPUT_LINE_HALT, ASSERT_LINE); subcpu_resetline = -1; } } } else { if (subcpu_resetline == 1 && (data != 0x0c)) { cpunum_set_input_line(1, INPUT_LINE_RESET, CLEAR_LINE); subcpu_resetline = 0; if (pc == 0xbb0 || pc == 0x9d30 || pc == 0xb19c) cpu_spinuntil_time(TIME_IN_USEC(15000)); /* sync semaphore */ } else if (subcpu_resetline == -1) { cpunum_set_input_line(1, INPUT_LINE_HALT, CLEAR_LINE); subcpu_resetline = 0; } } }
static void via_irq(int state) { /* Kaos sits in a tight loop polling the VIA irq flags register, but that register is cleared by the irq handler. Therefore, I wait a bit before triggering the irq to leave time for the program to see the flag change. */ timer_set(TIME_IN_USEC(50), state, via_irq_delayed); }
void digdug_customio_w(int offset,int data) { if (errorlog && data != 0x10 && data != 0x71) fprintf(errorlog,"%04x: custom IO command %02x\n",cpu_get_pc(),data); customio_command = data; switch (data) { case 0x10: if (nmi_timer) timer_remove (nmi_timer); nmi_timer = 0; return; case 0xa1: /* go into switch mode */ mode = 1; break; case 0xc1: case 0xe1: /* go into credit mode */ mode = 0; break; case 0xb1: /* status? */ credits = 0; /* this is a good time to reset the credits counter */ break; } nmi_timer = timer_pulse (TIME_IN_USEC (50), 0, digdug_nmi_generate); }
static void coco_fdc_callback(int event) { switch(event) { case WD179X_IRQ_CLR: intrq_state = CLEAR_LINE; cpunum_set_input_line(0, INPUT_LINE_NMI, CLEAR_LINE); break; case WD179X_IRQ_SET: intrq_state = ASSERT_LINE; CLEAR_COCO_HALTENABLE; coco_set_halt_line(CLEAR_LINE); if( COCO_NMIENABLE ) timer_set( TIME_IN_USEC(0), 0, raise_nmi); else cpunum_set_input_line(0, INPUT_LINE_NMI, CLEAR_LINE); break; case WD179X_DRQ_CLR: drq_state = CLEAR_LINE; if( COCO_HALTENABLE ) timer_set( TIME_IN_CYCLES(7,0), 0, raise_halt); else coco_set_halt_line(CLEAR_LINE); break; case WD179X_DRQ_SET: drq_state = ASSERT_LINE; coco_set_halt_line(CLEAR_LINE); break; } }
void gottlieb_speech_w(int offset, int data) { data ^= 255; /* generate a NMI after a while to make the CPU continue to send data */ timer_set(TIME_IN_USEC(50),0,gottlieb_nmi_generate); }
void centronics_write_handshake(int nr, int data, int mask) { CENTRONICS *This=cent+nr; int neu=(data&mask)|(This->control&(~mask)); if (neu & CENTRONICS_NO_RESET) { if ( !(This->control&CENTRONICS_STROBE) && (neu&CENTRONICS_STROBE) ) { printer_output(image_from_devtype_and_index(IO_PRINTER, nr), This->data); /* setup timer for data acknowledge */ /* set mask for data that has changed */ This->new_control_mask = CENTRONICS_ACKNOWLEDGE; /* set data that has changed */ This->new_control_data = CENTRONICS_ACKNOWLEDGE; /* setup a new timer */ timer_adjust(This->timer, TIME_IN_USEC(1), nr, 0); } } This->control=neu; }
static void cpu_vblankcallback(int param) { int cpunum; if (vblank_countdown == 1) vblank = 1; /* loop over CPUs */ for (cpunum = 0; cpunum < cpu_gettotalcpu(); cpunum++) { /* if the interrupt multiplier is valid */ if (cpu[cpunum].vblankint_multiplier != -1) { /* decrement; if we hit zero, generate the interrupt and reset the countdown */ if (!--cpu[cpunum].vblankint_countdown) { /* a param of -1 means don't call any callbacks */ if (param != -1) { /* if the CPU has a VBLANK handler, call it */ if (Machine->drv->cpu[cpunum].vblank_interrupt && cpu_getstatus(cpunum)) { cpuintrf_push_context(cpunum); (*Machine->drv->cpu[cpunum].vblank_interrupt)(); cpuintrf_pop_context(); } /* update the counters */ cpu[cpunum].iloops--; } /* reset the countdown and timer */ cpu[cpunum].vblankint_countdown = cpu[cpunum].vblankint_multiplier; timer_adjust(cpu[cpunum].vblankint_timer, TIME_NEVER, 0, 0); } } /* else reset the VBLANK timer if this is going to be a real VBLANK */ else if (vblank_countdown == 1) timer_adjust(cpu[cpunum].vblankint_timer, TIME_NEVER, 0, 0); } /* is it a real VBLANK? */ if (!--vblank_countdown) { /* do we update the screen now? */ if (!(Machine->drv->video_attributes & VIDEO_UPDATE_AFTER_VBLANK)) time_to_quit = updatescreen(); /* Set the timer to update the screen */ timer_set(TIME_IN_USEC(Machine->drv->vblank_duration), 0, cpu_updatecallback); /* reset the globals */ cpu_vblankreset(); /* reset the counter */ vblank_countdown = vblank_multiplier; } }
static void set_coco_dskreg(int data) { UINT8 drive = 0; UINT8 head = 0; int motor_mask = 0; LOG(("set_coco_dskreg(): %c%c%c%c%c%c%c%c ($%02x)\n", data & 0x80 ? 'H' : 'h', data & 0x40 ? '3' : '.', data & 0x20 ? 'D' : 'S', data & 0x10 ? 'P' : 'p', data & 0x08 ? 'M' : 'm', data & 0x04 ? '2' : '.', data & 0x02 ? '1' : '.', data & 0x01 ? '0' : '.', data )); /* An email from John Kowalski informed me that if the DS3 is * high, and one of the other drive bits is selected (DS0-DS2), then the * second side of DS0, DS1, or DS2 is selected. If multiple bits are * selected in other situations, then both drives are selected, and any * read signals get yucky. */ motor_mask = 0x08; if (data & 0x04) drive = 2; else if (data & 0x02) drive = 1; else if (data & 0x01) drive = 0; else if (data & 0x40) drive = 3; else motor_mask = 0; head = ((data & 0x40) && (drive != 3)) ? 1 : 0; dskreg = data; if( COCO_HALTENABLE && (drq_state == CLEAR_LINE) ) timer_set( TIME_IN_CYCLES(7,0), 0, raise_halt); else coco_set_halt_line(CLEAR_LINE); if( COCO_NMIENABLE && (intrq_state == ASSERT_LINE) ) { CLEAR_COCO_HALTENABLE; coco_set_halt_line(CLEAR_LINE); timer_set( TIME_IN_USEC(0), 0, raise_nmi); } else cpunum_set_input_line(0, INPUT_LINE_NMI, CLEAR_LINE); wd179x_set_drive(drive); wd179x_set_side(head); wd179x_set_density( (dskreg & 0x20) ? DEN_MFM_LO : DEN_FM_LO ); }
static void josvolly_8741_do(int num) { if( (i8741[num].sts & 0x02) ) { /* transmit data */ timer_set (TIME_IN_USEC(1),num,josvolly_8741_tx); } }
int foodf_interrupt (void) { /* INT 2 once per frame in addition to... */ if (cpu_getiloops () == 0) timer_set (TIME_IN_USEC (100), 0, foodf_delayed_interrupt); /* INT 1 on the 32V signal */ return 1; }
static void delayed_sound_w(int param) { main_to_sound_data = param; main_to_sound_ready = 1; cpu_triggerint(1); /* use a timer to make long transfers faster */ timer_set(TIME_IN_USEC(50), 0, 0); }
static WRITE16_HANDLER( othunder_lightgun_w ) { /* A write starts the A/D conversion. An interrupt will be triggered when the conversion is complete. The ADC60808 clock is 512kHz. Conversion takes between 0 and 8 clock cycles, so would end in a maximum of 15.625us. We'll use 10. */ timer_set(TIME_IN_USEC(10),0, ad_interrupt); }
static WRITE_HANDLER( xain_sharedram_w ) { /* locations 003d and 003e are used as a semaphores between CPU A and B, */ /* so let's resync every time they are changed to avoid deadlocks */ if ((offset == 0x003d || offset == 0x003e) && xain_sharedram[offset] != data) cpu_boost_interleave(0, TIME_IN_USEC(20)); xain_sharedram[offset] = data; }
static void apple1_dsp_ready_start(int dummy) { /* When the display asserts \RDA to signal it is ready, it triggers a 74123 one-shot to send a 3.5-usec low pulse to PIA input CB1. The end of this pulse will tell the PIA that the display is ready for another write. */ pia_set_input_cb1(0, 0); timer_set(TIME_IN_USEC(3.5), 0, apple1_dsp_ready_end); }
void cpu_compute_scanline_timing(void) { if (Machine->drv->vblank_duration) scanline_period = (refresh_period - TIME_IN_USEC(Machine->drv->vblank_duration)) / (double)(Machine->drv->default_visible_area.max_y - Machine->drv->default_visible_area.min_y + 1); else scanline_period = refresh_period / (double)Machine->drv->screen_height; scanline_period_inv = 1.0 / scanline_period; }
static WRITE16_HANDLER( roldf_sh_irqtrigger_w ) { if (ACCESSING_LSB) { soundlatch_w(0,data & 0xff); cpunum_set_input_line(1,0,HOLD_LINE); } // give the z80 time to see it cpu_spinuntil_time(TIME_IN_USEC(40)); }
static WRITE16_HANDLER( fuuki16_sound_command_w ) { if (ACCESSING_LSB) { soundlatch_w(0,data & 0xff); cpunum_set_input_line(1, INPUT_LINE_NMI, PULSE_LINE); // cpu_spinuntil_time(TIME_IN_USEC(50)); // Allow the other CPU to reply cpu_boost_interleave(0, TIME_IN_USEC(50)); // Fixes glitching in rasters } }
static MACHINE_RESET( super8 ) { /* reset PIO */ z80pio_init(0, &z80pio_intf); z80pio_reset(0); keyboard_scan(); /* enable ROM in base >0000, and re-enable RAM shortly thereafter */ memory_set_bankptr(1, memory_region(REGION_CPU1) + 0xC000); timer_set(TIME_IN_USEC(10), 0, reset_timer_callback); }
void Create_Attacker_List(char *router_ip, char *attacker_ip, char * victim_ip) { struct attacker_list *p; struct router_list *p_routerlist, *new_routerlist; if(routerAttackerHead == NULL) { routerAttackerHead = create_attackerlist_node(router_ip, attacker_ip, victim_ip); } else { p = routerAttackerHead; while(p != NULL) { if(strncmp(p->attacker_ip_addr, attacker_ip, MAXIPADDRLEN) == 0) { p_routerlist = p->routerhead; while(p_routerlist != NULL) { if(strncmp(p_routerlist->router_ip, router_ip, MAXIPADDRLEN) == 0) { p_routerlist->frequency++; goto end; } p_routerlist = p_routerlist->next; } if(p_routerlist == NULL) { new_routerlist = (struct router_list *)malloc(sizeof(struct router_list)); memset(new_routerlist, '\0', sizeof(struct router_list)); strncpy(new_routerlist->router_ip, router_ip, strlen(router_ip)); new_routerlist->frequency = 1; new_routerlist->next = p->routerhead; p->routerhead = new_routerlist; p->no_of_routers++; struct timeval curtime; gettimeofday(&curtime, NULL); LOG(fp_log, LOGL, "%f %s distance", SEC(TIME_IN_USEC(curtime)), router_ip); goto end; } } p = p->next; } end: if(p == NULL) { p = create_attackerlist_node(router_ip, attacker_ip, victim_ip); p->next = routerAttackerHead; routerAttackerHead = p; } } }
static void psx_pad_ack( int n_port ) { if( m_pad[ n_port ].n_state != PAD_STATE_IDLE ) { psx_sio_input( 0, PSX_SIO_IN_DSR, m_pad[ n_port ].b_ack * PSX_SIO_IN_DSR ); if( !m_pad[ n_port ].b_ack ) { m_pad[ n_port ].b_ack = 1; timer_set( TIME_IN_USEC( 2 ), n_port, psx_pad_ack ); } } }
static void sound_command_w(int data) { exidy440_sound_command = data; exidy440_sound_command_ack = 0; cpunum_set_input_line(1, INPUT_LINE_IRQ1, ASSERT_LINE); /* It is important that the sound cpu ACKs the sound command quickly. Otherwise the main CPU gives up with sound. Boosting the interleave for a while helps. */ cpu_boost_interleave(0, TIME_IN_USEC(100)); }
static void delayed_gamma_w(int data) { /* mark the data received */ gamma_rcvd = 0; alpha_xmtd = 1; alpha_data = data; /* signal with an NMI pulse */ cpunum_set_input_line(1, INPUT_LINE_NMI, PULSE_LINE); /* the sound CPU needs to reply in 250microseconds (according to Neil Bradley) */ timer_set(TIME_IN_USEC(250), 0, 0); }
static INTERRUPT_GEN( simpsons_irq ) { if (K053246_is_IRQ_enabled()) { simpsons_objdma(); // 32+256us delay at 8MHz dotclock; artificially shortened since actual V-blank length is unknown timer_set(TIME_IN_USEC(30), 0, dmaend_callback); } if (K052109_is_IRQ_enabled()) cpunum_set_input_line(0, KONAMI_IRQ_LINE, HOLD_LINE); }
static WRITE8_HANDLER( qixmcu_coinctrl_w ) { if (data & 0x04) { cpunum_set_input_line(3, M6809_IRQ_LINE, ASSERT_LINE); /* temporarily boost the interleave to sync things up */ /* note: I'm using 50 because 30 is not enough for space dungeon at game over */ cpu_boost_interleave(0, TIME_IN_USEC(50)); } else cpunum_set_input_line(3, M6809_IRQ_LINE, CLEAR_LINE); /* this is a callback called by pia_0_w(), so I don't need to synchronize */ /* the CPUs - they have already been synchronized by qix_pia_0_w() */ qix_coinctrl = data; }
static INTERRUPT_GEN( gijoe_interrupt ) { // global interrupt masking (*this game only) if (!K056832_is_IRQ_enabled(0)) return; if (K053246_is_IRQ_enabled()) { gijoe_objdma(); // 42.7us(clr) + 341.3us(xfer) delay at 6Mhz dotclock timer_adjust(dmadelay_timer, TIME_IN_USEC(JOE_DMADELAY), 0, 0); } // trigger V-blank interrupt if (cur_control2 & 0x0080) cpunum_set_input_line(0, 5, HOLD_LINE); }
static void read_next_sector(struct ide_state *ide) { /* mark ourselves busy */ ide->status |= IDE_STATUS_BUSY; if (ide->command == IDE_COMMAND_READ_MULTIPLE_BLOCK) { if (ide->sectors_until_int != 1) /* make ready now */ read_sector_done(ide - idestate); else /* just set a timer */ timer_set(TIME_IN_USEC(1), ide - idestate, read_sector_done); } else /* just set a timer */ timer_set(TIME_PER_SECTOR, ide - idestate, read_sector_done); }
void send_start_marking_msg(char *router_ip, int tcpport) { int fd; struct sockaddr_in router_addr; struct hostent *router_ip_addr; struct in_addr * address; struct timeval curtime; socklen_t alen = sizeof(struct sockaddr_in); char my_message[BUFSIZE]; memset(my_message, 0, BUFSIZE); if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { LOG(stderr, ERROR, "cannot create socket"); } memset((char*)&router_addr, 0, sizeof(struct sockaddr_in)); router_addr.sin_family = AF_INET; router_addr.sin_port = htons(tcpport); router_ip_addr = gethostbyname(router_ip); address = (struct in_addr *)router_ip_addr->h_addr; router_addr.sin_addr.s_addr = inet_addr(inet_ntoa(*address)); if (connect(fd, (struct sockaddr *)&router_addr, alen) == -1) { close(fd); perror("TCP connection error"); exit(0); } snprintf(my_message,BUFSIZE,"startMarking %s",router_ip); if(write(fd, my_message, BUFSIZE) < 0) { close(fd); perror("Endhost: Error in write() for victim client"); exit(0); } LOG(stdout, LOGL, "EndHost: StartMarking message is sent to Router(IP: %s, TCP: %d)",router_ip, tcpport); gettimeofday(&curtime, NULL); LOG(fp_log, LOGL, "%f startMarking %s \'%s\'", SEC(TIME_IN_USEC(curtime)), router_ip, my_message); close(fd); }
struct attacker_list *create_attackerlist_node(char *router_ip_addr, char *attacker_ip_addr, char *victim_ip_addr) { struct attacker_list *newNode = (struct attacker_list *)malloc(sizeof(struct attacker_list)); memset(newNode->attacker_ip_addr,'\0',MAXIPADDRLEN); memset(newNode->victim_ip_addr,'\0',MAXIPADDRLEN); strncpy(newNode->attacker_ip_addr, attacker_ip_addr, strlen(attacker_ip_addr)); strncpy(newNode->victim_ip_addr, victim_ip_addr, strlen(victim_ip_addr)); newNode->routerhead = (struct router_list *)malloc(sizeof(struct router_list)); memset(newNode->routerhead,'\0',sizeof(struct router_list)); strncpy(newNode->routerhead->router_ip, router_ip_addr, strlen(router_ip_addr)); struct timeval curtime; gettimeofday(&curtime, NULL); LOG(fp_log, LOGL, "%f %s distance", SEC(TIME_IN_USEC(curtime)), router_ip_addr); newNode->routerhead->frequency = 1; newNode->routerhead->next = NULL; newNode->no_of_routers = 1; newNode->next = NULL; return newNode; }