threshold
long long threshold = 0x100000000LL; /* 0xffffffff + 1 */
threshold /= rate;
b0 = gen_relation(BPF_JGT, gen_loadrnd(), gen_loadi(threshold), 1);
int threshold;
_rthread_debug(6, "in: %d, threshold: %d\n", b->in, b->threshold);
if (++b->in == b->threshold) {
b->threshold = count;
struct threshold *thr;
thr = attr_thr.threshold;
struct threshold threshold[30];
plic_set_threshold(int cpu, uint32_t threshold)
if (threshold < 4) // enable everything (as far as plic is concerned)
else if (threshold >= 12) // invalid priority level ?
prival = threshold - 4; // XXX Device-specific threshold offset
uint32_t threshold;
malo_cmd_set_rts(struct malo_softc *sc, uint32_t threshold)
body->threshold = htole32(threshold);
int malo_cmd_set_rts(struct malo_softc *sc, uint32_t threshold);
RB_USED_INT_THRESHOLD, threshold);
u32 threshold, u32 timeout, bool enabled)
RB_USED_INT_THRESHOLD, threshold);
u32 threshold, u32 timeout, bool enabled)
RB_USED_INT_THRESHOLD, threshold);
u32 threshold, u32 timeout, bool enabled)
u32 threshold, u32 timeout, bool enabled)
RB_USED_INT_THRESHOLD, threshold);
RB_USED_INT_THRESHOLD, threshold);
struct fixed31_32 threshold;
threshold = dc_fixpt_from_fraction(1, 2);
if (dc_fixpt_lt(in_x, threshold)) {
struct fixed31_32 threshold;
threshold = dc_fixpt_from_fraction(1, 12);
if (dc_fixpt_lt(x, threshold)) {
u32 threshold;
threshold = state->performance_levels[state->performance_level_count-1].sclk * 100 / 100;
(state->performance_levels[i].sclk < threshold) ?
threshold / 512);
static bool is_disabling(int old, int new, int threshold)
return old >= threshold && new < threshold;
static bool is_enabling(int old, int new, int threshold)
return old < threshold && new >= threshold;
const int threshold = hpd->hpd_storm_threshold;
if (!threshold ||
if (hpd->stats[pin].count > threshold) {
static int rps_set_threshold(struct intel_rps *rps, u8 *threshold, u8 val)
if (*threshold == val)
*threshold = val;
int intel_rps_set_up_threshold(struct intel_rps *rps, u8 threshold)
return rps_set_threshold(rps, &rps->power.up_threshold, threshold);
int intel_rps_set_down_threshold(struct intel_rps *rps, u8 threshold)
return rps_set_threshold(rps, &rps->power.down_threshold, threshold);
int intel_rps_set_up_threshold(struct intel_rps *rps, u8 threshold);
int intel_rps_set_down_threshold(struct intel_rps *rps, u8 threshold);
threshold = (9 * NSEC_PER_MSEC * sleep_time) / 10;
if (diff < threshold)
u64 threshold;
int threshold)
return s_job && atomic_inc_return(&s_job->karma) > threshold;
u32 threshold = state->performance_levels[state->performance_level_count - 1].sclk * 100 / 100;
(state->performance_levels[i].sclk < threshold) ?
cpu_to_be32(threshold / 512));
u32 threshold;
threshold = state->performance_levels[state->performance_level_count-1].sclk * 100 / 100;
(state->performance_levels[i].sclk < threshold) ?
threshold / 512);
sc->record.threshold = sc->record.start;
sc->play.threshold = sc->play.start;
if (pos >= ch->threshold &&
pos < ch->threshold + ch->blocksize/2)
ch->threshold += ch->blocksize/2;
if (ch->threshold >= ch->end)
ch->threshold = ch->start;
u_int16_t threshold;
uint32_t flow, threshold;
threshold = 0;
threshold = 0x820;
threshold =
MUE_FCT_FLOW : MUE_7800_FCT_FLOW, threshold);
int threshold; /* Changes less than this are ignored. */
.threshold = 5, \
sc->sc_threshold = pd->threshold;
detect_pos(int *sensors, int n_sensors, int threshold, int fact,
if (sensors[i] >= threshold) {
if (i == 0 || sensors[i - 1] < threshold)
s += sensors[i] - threshold;
w += (sensors[i] - threshold) * i;
pf_init_threshold(struct pf_threshold *threshold,
threshold->limit = limit * PF_THRESHOLD_MULT;
threshold->seconds = seconds;
threshold->count = 0;
threshold->last = getuptime();
pf_add_threshold(struct pf_threshold *threshold)
u_int32_t t = getuptime(), diff = t - threshold->last;
if (diff >= threshold->seconds)
threshold->count = 0;
threshold->count -= threshold->count * diff /
threshold->seconds;
threshold->count += PF_THRESHOLD_MULT;
threshold->last = t;
pf_check_threshold(struct pf_threshold *threshold)
return (threshold->count > threshold->limit);
int threshold, npaths = 1;
threshold = (0xffff / npaths) + 1;
while (hash > threshold) {
hash -= threshold;
log_ratelimit_init(struct log_ratelimit_ctx *rl, u_int threshold,
rl->threshold = threshold;
rl, rl->threshold, rl->max_accum, rl->hysteresis, rl->log_every));
"accum=%u since=%ld since_last=%u", rl, rl->threshold,
rl->accumulated_events, rl->threshold));
if (rl->accumulated_events < rl->threshold) {
void log_ratelimit_init(struct log_ratelimit_ctx *rl, u_int threshold,
u_int threshold; /* events per second */
u_char metric, threshold, ncount;
threshold = *p++;
|| nb_i->threshold != nb_n->threshold)
if (metric != nb->metric || threshold != nb->threshold)
nb->threshold = threshold;
u_char metric, threshold, ncount, flags;
threshold = *p++;
|| nb_i->threshold != nb_n->threshold)
if (metric != nb->metric || threshold != nb->threshold)
nb->threshold = threshold;
u_char threshold; /* TTL threshold to forward */
printf(" [%d/%d", nb->metric, nb->threshold);
nb_node->addr, nb->metric, nb->threshold);
|| nb2->threshold != nb->threshold))
printf(",%d/%d", nb2->metric, nb2->threshold);
vif_list[vifi].threshold = v->uv_threshold;
u_char threshold; /* vif threshold ttl */