void RelocIterator::print() {
RelocIterator save_this = (*this);
relocInfo* scan = _current;
if (!has_current()) scan += 1; // nothing to scan here!
bool skip_next = has_current();
bool got_next;
while (true) {
got_next = (skip_next || next());
skip_next = false;
tty->print(" @" INTPTR_FORMAT ": ", scan);
relocInfo* newscan = _current+1;
if (!has_current()) newscan -= 1; // nothing to scan here!
while (scan < newscan) {
tty->print("%04x", *(short*)scan & 0xFFFF);
scan++;
}
tty->cr();
if (!got_next) break;
print_current();
}
(*this) = save_this;
}
/// exhausted - returns true if the voltage remains below the low_voltage for 10 seconds or remaining capacity falls below min_capacity_mah
bool AP_BattMonitor::exhausted(uint8_t instance, float low_voltage, float min_capacity_mah)
{
// exit immediately if no monitors setup
if (_num_instances == 0 || instance >= AP_BATT_MONITOR_MAX_INSTANCES || drivers[instance] == NULL) {
return false;
}
// get current time
uint32_t tnow = AP_HAL::millis();
// check voltage
if ((state[instance].voltage > 0.0f) && (low_voltage > 0) && (state[instance].voltage < low_voltage)) {
// this is the first time our voltage has dropped below minimum so start timer
if (state[instance].low_voltage_start_ms == 0) {
state[instance].low_voltage_start_ms = tnow;
}else if (tnow - state[instance].low_voltage_start_ms > AP_BATT_LOW_VOLT_TIMEOUT_MS) {
return true;
}
}else{
// acceptable voltage so reset timer
state[instance].low_voltage_start_ms = 0;
}
// check capacity if current monitoring is enabled
if (has_current(instance) && (min_capacity_mah>0) && (_pack_capacity[instance] - state[instance].current_total_mah < min_capacity_mah)) {
return true;
}
// if we've gotten this far battery is ok
return false;
}
/// exhausted - returns true if the voltage remains below the low_voltage for 10 seconds or remaining capacity falls below min_capacity_mah
bool AP_BattMonitor::exhausted(uint8_t instance, float low_voltage, float min_capacity_mah)
{
// exit immediately if no monitors setup
if (_num_instances == 0 || instance >= _num_instances) {
return false;
}
// check voltage
if ((state[instance].voltage > 0) && (low_voltage > 0) && (state[instance].voltage < low_voltage)) {
// this is the first time our voltage has dropped below minimum so start timer
if (state[instance].low_voltage_start_ms == 0) {
state[instance].low_voltage_start_ms = AP_HAL::millis();
} else if (_volt_timeout > 0 && AP_HAL::millis() - state[instance].low_voltage_start_ms > uint32_t(_volt_timeout.get())*1000U) {
return true;
}
} else {
// acceptable voltage so reset timer
state[instance].low_voltage_start_ms = 0;
}
// check capacity if current monitoring is enabled
if (has_current(instance) && (min_capacity_mah > 0) && (_pack_capacity[instance] - state[instance].current_total_mah < min_capacity_mah)) {
return true;
}
// if we've gotten this far then battery is ok
return false;
}
// read - read the voltage and current
void
AP_BattMonitor_Analog::read()
{
// this copes with changing the pin at runtime
_volt_pin_analog_source->set_pin(_params._volt_pin);
// get voltage
_state.voltage = _volt_pin_analog_source->voltage_average() * _params._volt_multiplier;
// read current
if (has_current()) {
// calculate time since last current read
uint32_t tnow = AP_HAL::micros();
float dt = tnow - _state.last_time_micros;
// this copes with changing the pin at runtime
_curr_pin_analog_source->set_pin(_params._curr_pin);
// read current
_state.current_amps = (_curr_pin_analog_source->voltage_average()-_params._curr_amp_offset)*_params._curr_amp_per_volt;
// update total current drawn since startup
if (_state.last_time_micros != 0 && dt < 2000000.0f) {
// .0002778 is 1/3600 (conversion to hours)
float mah = _state.current_amps * dt * 0.0000002778f;
_state.consumed_mah += mah;
_state.consumed_wh += 0.001f * mah * _state.voltage;
}
// record time
_state.last_time_micros = tnow;
}
}
void RelocIterator::initialize(intptr_t delta, CodeBlob* cb, address begin, address limit) {
#ifndef CORE
if (cb == NULL && delta == 0 && begin != NULL) {
// allow CodeBlob to be deduced from beginning address
cb = CodeCache::find_blob(begin);
}
assert(cb != NULL, "must be able to deduce nmethod from other arguments");
_code = cb;
_current = cb->relocation_begin()-1;
_end = cb->relocation_end();
_addr = (address) cb->instructions_begin();
assert(!has_current(), "just checking");
address code_end = cb->instructions_end();
assert(begin == NULL || begin >= delta + cb->instructions_begin(), "in bounds");
// FIX THIS assert(limit == NULL || limit <= delta + code_end, "in bounds");
if (begin != NULL) begin -= delta;
if (limit != NULL) limit -= delta;
set_limits(begin, limit);
// after limits have been set and indexes consulted, then apply the delta
if (delta == 0) {
_is_copy = false;
} else {
_is_copy = true;
_addr += delta; // we are operating on a copy of the code
_limit += delta;
}
#endif // !CORE
}
RelocIterator::RelocIterator(CodeBuffer* cb, address begin, address limit) {
#ifndef CORE
_current = cb->locs_start()-1;
_end = cb->locs_end();
_addr = (address) cb->code_begin();
_code = cb->get_blob();
assert(!has_current(), "just checking");
assert(begin == NULL || begin >= cb->code_begin(), "in bounds");
assert(limit == NULL || limit <= cb->code_end(), "in bounds");
set_limits(begin, limit);
#endif // !CORE
}
void RelocIterator::print_current() {
if (!has_current()) {
tty->print_cr("(no relocs)");
return;
}
tty->print("relocInfo@" INTPTR_FORMAT " [type=%d(%s) addr=" INTPTR_FORMAT,
_current, type(), reloc_type_string((relocInfo::relocType) type()), _addr);
if (current()->format() != 0)
tty->print(" format=%d", current()->format());
if (datalen() == 1) {
tty->print(" data=%d", data()[0]);
} else if (datalen() > 0) {
tty->print(" data={");
for (int i = 0; i < datalen(); i++) {
tty->print("%04x", data()[i] & 0xFFFF);
}
tty->print("}");
}
tty->print("]");
switch (type()) {
case relocInfo::oop_type:
{
oop_Relocation* r = oop_reloc();
oop* oop_addr = NULL;
oop raw_oop = NULL;
oop oop_value = NULL;
if (code() != NULL || r->oop_index() == 0) {
oop_addr = r->oop_addr();
raw_oop = *oop_addr;
oop_value = r->oop_value();
}
tty->print_cr(" | [oop_addr=" INTPTR_FORMAT " *=" INTPTR_FORMAT " offset=%d]",
oop_addr, raw_oop, r->offset());
// Do not print the oop by default--we want this routine to
// work even during GC or other inconvenient times.
if (WizardMode && oop_value != NULL) {
tty->print("oop_value=" INTPTR_FORMAT ": ", oop_value);
oop_value->print_value_on(tty);
}
break;
}
case relocInfo::external_word_type:
case relocInfo::internal_word_type:
{
DataRelocation* r = (DataRelocation*) reloc();
tty->print(" | [target=" INTPTR_FORMAT "]", r->value()); //value==target
break;
}
case relocInfo::static_call_type:
case relocInfo::runtime_call_type:
case relocInfo::jsr_type:
{
CallRelocation* r = (CallRelocation*) reloc();
tty->print(" | [destination=" INTPTR_FORMAT "]", r->destination());
break;
}
case relocInfo::virtual_call_type:
{
virtual_call_Relocation* r = (virtual_call_Relocation*) reloc();
tty->print(" | [destination=" INTPTR_FORMAT " first_oop=" INTPTR_FORMAT " oop_limit=" INTPTR_FORMAT "]",
r->destination(), r->first_oop(), r->oop_limit());
break;
}
case relocInfo::static_stub_type:
{
static_stub_Relocation* r = (static_stub_Relocation*) reloc();
tty->print(" | [static_call=" INTPTR_FORMAT "]", r->static_call());
break;
}
}
tty->cr();
}
