/** * Find first/last instruction that references each temporary register. */ GLboolean _mesa_find_temp_intervals(const struct prog_instruction *instructions, GLuint numInstructions, GLint intBegin[REG_ALLOCATE_MAX_PROGRAM_TEMPS], GLint intEnd[REG_ALLOCATE_MAX_PROGRAM_TEMPS]) { struct loop_info loopStack[MAX_LOOP_NESTING]; GLuint loopStackDepth = 0; GLuint i; for (i = 0; i < REG_ALLOCATE_MAX_PROGRAM_TEMPS; i++){ intBegin[i] = intEnd[i] = -1; } /* Scan instructions looking for temporary registers */ for (i = 0; i < numInstructions; i++) { const struct prog_instruction *inst = instructions + i; if (inst->Opcode == OPCODE_BGNLOOP) { loopStack[loopStackDepth].Start = i; loopStack[loopStackDepth].End = inst->BranchTarget; loopStackDepth++; } else if (inst->Opcode == OPCODE_ENDLOOP) { loopStackDepth--; } else if (inst->Opcode == OPCODE_CAL) { return GL_FALSE; } else { const GLuint numSrc = 3;/*_mesa_num_inst_src_regs(inst->Opcode);*/ GLuint j; for (j = 0; j < numSrc; j++) { if (inst->SrcReg[j].File == PROGRAM_TEMPORARY) { const GLuint index = inst->SrcReg[j].Index; if (inst->SrcReg[j].RelAddr) return GL_FALSE; update_interval(intBegin, intEnd, loopStack, loopStackDepth, index, i); } } if (inst->DstReg.File == PROGRAM_TEMPORARY) { const GLuint index = inst->DstReg.Index; if (inst->DstReg.RelAddr) return GL_FALSE; update_interval(intBegin, intEnd, loopStack, loopStackDepth, index, i); } } } return GL_TRUE; }
void move_unit(unit * u, region * r, unit ** ulist) { assert(u && r); assert(u->faction || !"this unit is dead"); if (u->region == r) return; if (!ulist) ulist = (&r->units); if (u->region) { setguard(u, GUARD_NONE); fset(u, UFL_MOVED); if (u->ship || u->building) { /* can_leave must be checked in travel_i */ #ifndef NDEBUG bool result = leave(u, false); assert(result); #else leave(u, false); #endif } translist(&u->region->units, ulist, u); } else { addlist(ulist, u); } #ifdef SMART_INTERVALS update_interval(u->faction, r); #endif u->region = r; }
void u_setfaction(unit * u, faction * f) { int cnt = u->number; if (u->faction == f) return; if (u->faction) { set_number(u, 0); if (count_unit(u)) --u->faction->no_units; join_group(u, NULL); free_orders(&u->orders); set_order(&u->thisorder, NULL); if (u->nextF) u->nextF->prevF = u->prevF; if (u->prevF) u->prevF->nextF = u->nextF; else u->faction->units = u->nextF; } if (f != NULL) { if (f->units) f->units->prevF = u; u->prevF = NULL; u->nextF = f->units; f->units = u; } else u->nextF = NULL; u->faction = f; if (u->region) update_interval(f, u->region); if (cnt && f) { set_number(u, cnt); if (count_unit(u)) ++f->no_units; } }
int gather_statistics(__u8 *icmph, int icmplen, int cc, __u16 seq, int hops, int csfailed, struct timeval *tv, char *from, void (*pr_reply)(__u8 *icmph, int cc)) { int dupflag = 0; long triptime = 0; __u8 *ptr = icmph + icmplen; ++nreceived; if (!csfailed) acknowledge(seq); if (timing && cc >= 8+sizeof(struct timeval)) { struct timeval tmp_tv; memcpy(&tmp_tv, ptr, sizeof(tmp_tv)); restamp: tvsub(tv, &tmp_tv); triptime = tv->tv_sec * 1000000 + tv->tv_usec; if (triptime < 0) { fprintf(stderr, "Warning: time of day goes back (%ldus), taking countermeasures.\n", triptime); triptime = 0; if (!(options & F_LATENCY)) { gettimeofday(tv, NULL); options |= F_LATENCY; goto restamp; } } if (!csfailed) { tsum += triptime; tsum2 += (long long)triptime * (long long)triptime; if (triptime < tmin) tmin = triptime; if (triptime > tmax) tmax = triptime; if (!rtt) rtt = triptime*8; else rtt += triptime-rtt/8; if (options&F_ADAPTIVE) update_interval(); } } if (csfailed) { ++nchecksum; --nreceived; } else if (rcvd_test(seq)) { ++nrepeats; --nreceived; dupflag = 1; } else { rcvd_set(seq); dupflag = 0; } confirm = confirm_flag; if (options & F_QUIET) return 1; if (options & F_FLOOD) { if (!csfailed) write_stdout("\b \b", 3); else write_stdout("\bC", 2); } else { int i; __u8 *cp, *dp; print_timestamp(); printf("%d bytes from %s:", cc, from); if (pr_reply) pr_reply(icmph, cc); if (hops >= 0) printf(" ttl=%d", hops); if (cc < datalen+8) { printf(" (truncated)\n"); return 1; } if (timing) { if (triptime >= 100000) printf(" time=%ld ms", triptime/1000); else if (triptime >= 10000) printf(" time=%ld.%01ld ms", triptime/1000, (triptime%1000)/100); else if (triptime >= 1000) printf(" time=%ld.%02ld ms", triptime/1000, (triptime%1000)/10); else printf(" time=%ld.%03ld ms", triptime/1000, triptime%1000); } if (dupflag) printf(" (DUP!)"); if (csfailed) printf(" (BAD CHECKSUM!)"); /* check the data */ cp = ((u_char*)ptr) + sizeof(struct timeval); dp = &outpack[8 + sizeof(struct timeval)]; for (i = sizeof(struct timeval); i < datalen; ++i, ++cp, ++dp) { if (*cp != *dp) { printf("\nwrong data byte #%d should be 0x%x but was 0x%x", i, *dp, *cp); cp = (u_char*)ptr + sizeof(struct timeval); for (i = sizeof(struct timeval); i < datalen; ++i, ++cp) { if ((i % 32) == sizeof(struct timeval)) printf("\n#%d\t", i); printf("%x ", *cp); } break; } } } return 0; }
/* * pinger -- * Compose and transmit an ICMP ECHO REQUEST packet. The IP packet * will be added on by the kernel. The ID field is our UNIX process ID, * and the sequence number is an ascending integer. The first 8 bytes * of the data portion are used to hold a UNIX "timeval" struct in VAX * byte-order, to compute the round-trip time. */ int pinger(void) { static int oom_count; static int tokens; int i; /* Have we already sent enough? If we have, return an arbitrary positive value. */ if (exiting || (npackets && ntransmitted >= npackets && !deadline)) return 1000; /* Check that packets < rate*time + preload */ if (cur_time.tv_sec == 0) { gettimeofday(&cur_time, NULL); tokens = interval*(preload-1); } else { long ntokens; struct timeval tv; gettimeofday(&tv, NULL); ntokens = (tv.tv_sec - cur_time.tv_sec)*1000 + (tv.tv_usec-cur_time.tv_usec)/1000; if (!interval) { /* Case of unlimited flood is special; * if we see no reply, they are limited to 100pps */ if (ntokens < MININTERVAL && in_flight() >= preload) return MININTERVAL-ntokens; } ntokens += tokens; if (ntokens > interval*preload) ntokens = interval*preload; if (ntokens < interval) return interval - ntokens; cur_time = tv; tokens = ntokens - interval; } if (options & F_OUTSTANDING) { if (ntransmitted > 0 && !rcvd_test(ntransmitted)) { print_timestamp(); printf("no answer yet for icmp_seq=%lu\n", (ntransmitted % MAX_DUP_CHK)); fflush(stdout); } } resend: i = send_probe(); if (i == 0) { oom_count = 0; advance_ntransmitted(); if (!(options & F_QUIET) && (options & F_FLOOD)) { /* Very silly, but without this output with * high preload or pipe size is very confusing. */ if ((preload < screen_width && pipesize < screen_width) || in_flight() < screen_width) write_stdout(".", 1); } return interval - tokens; } /* And handle various errors... */ if (i > 0) { /* Apparently, it is some fatal bug. */ abort(); } else if (errno == ENOBUFS || errno == ENOMEM) { int nores_interval; /* Device queue overflow or OOM. Packet is not sent. */ tokens = 0; /* Slowdown. This works only in adaptive mode (option -A) */ rtt_addend += (rtt < 8*50000 ? rtt/8 : 50000); if (options&F_ADAPTIVE) update_interval(); nores_interval = SCHINT(interval/2); if (nores_interval > 500) nores_interval = 500; oom_count++; if (oom_count*nores_interval < lingertime) return nores_interval; i = 0; /* Fall to hard error. It is to avoid complete deadlock * on stuck output device even when dealine was not requested. * Expected timings are screwed up in any case, but we will * exit some day. :-) */ } else if (errno == EAGAIN) { /* Socket buffer is full. */ tokens += interval; return MININTERVAL; } else { if ((i=receive_error_msg()) > 0) { /* An ICMP error arrived. */ tokens += interval; return MININTERVAL; } /* Compatibility with old linuces. */ if (i == 0 && confirm_flag && errno == EINVAL) { confirm_flag = 0; errno = 0; } if (!errno) goto resend; } /* Hard local error. Pretend we sent packet. */ advance_ntransmitted(); if (i == 0 && !(options & F_QUIET)) { if (options & F_FLOOD) write_stdout("E", 1); else perror("ping: sendmsg"); } tokens = 0; return SCHINT(interval); }