double Stats::mean() const {
DEBUG_SINVARIANT(checkInvariants());
if (number == 0) {
return 0.0;
} else {
return double(sum)/double(number);
}
};
/* implicit */ AliasIdSet::AliasIdSet(uint32_t id) {
if (id <= BitsetMax) {
m_bits = Empty | (1ull << id);
} else {
m_bits = id;
}
assertx(checkInvariants());
}
void PackedArray::OnSetEvalScalar(ArrayData* ad) {
assert(checkInvariants(ad));
auto ptr = packedData(ad);
auto const stop = ptr + ad->m_packedCap;
for (; ptr != stop; ++ptr) {
tvAsVariant(ptr).setEvalScalar();
}
}
int main(void){
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer
PM5CTL0 &= ~LOCKLPM5;
initializeHardware();
reboots++;
DINO_RESTORE_CHECK();
DINO_TASK_BOUNDARY(START_TASK,NULL);
if( finished == 0xBEEE ){
#if defined(WISP5)
PJOUT |= BIT6;
#elif defined(BREADBOARD)
P4OUT |= BIT4;
#endif
while( 1 ){ }
}
if( inErrorState == 0xBEEE ){
abortWithError();
}
initializeNVData();
while( numSamples < (NUM_ITERS * SAMPLES_PER_ITER) ){
int r;
for(r = 0; r < SAMPLES_PER_ITER; r++){
DINO_TASK_BOUNDARY(SAMPLE_TASK,NULL);
unsigned samp = getOneSample();
DINO_TASK_BOUNDARY(BIN_TASK,NULL);
addToBin(samp);
numSamples++;
}
DINO_TASK_BOUNDARY(SORT_TASK,NULL);
sortBinsByFrequency();
DINO_TASK_BOUNDARY(CHECK_TASK,NULL);
checkInvariants();
}
finished = 0xBEEE;
#if defined(WISP5)
PJOUT |= BIT6;
#elif defined(BREADBOARD)
P4OUT |= BIT4;
#endif
while( 1 ){ }
}
void Stats::reset() {
DEBUG_SINVARIANT(checkInvariants());
StatsBase::reset();
number = 0;
sum = 0.0;
sumsq = 0.0;
min_value = Double::Inf;
max_value = -Double::Inf;
}
VectorEpetra<T>::VectorEpetra ( Epetra_FEVector const * v )
:
super( v->Map().NumGlobalElements(), v->Map().NumMyElements() ),
M_emap( v->Map() ),
M_vec( *v )
{
this->init( M_emap, true );
checkInvariants();
}
VectorEpetra<T>::VectorEpetra ( Epetra_BlockMap const& emap )
:
super( emap.NumGlobalElements(), emap.NumMyElements() ),
M_emap( emap ),
M_vec( M_emap )
//M_destroy_vec_on_exit( true )
{
this->init( M_emap, true );
checkInvariants();
}
VectorEpetra<T>::VectorEpetra ( VectorEpetra const& v )
:
super( v ),
M_emap( v.Map() ),
M_vec( v.vec() )
{
this->M_is_initialized = true;
checkInvariants();
}
NEVER_INLINE
ArrayData* PackedArray::Grow(ArrayData* old) {
assert(checkInvariants(old));
assert(old->m_size == old->m_packedCap);
DEBUG_ONLY auto const oldPos = old->m_pos;
auto const oldCap = old->m_packedCap;
auto const cap = oldCap * 2;
if (UNLIKELY(cap >= kMaxPackedCap)) return nullptr;
auto const ad = static_cast<ArrayData*>(
MM().objMallocLogged(sizeof(ArrayData) + cap * sizeof(TypedValue))
);
auto const oldSize = old->m_size;
auto const oldPosUnsigned = uint64_t{static_cast<uint32_t>(old->m_pos)};
ad->m_kindAndSize = uint64_t{oldSize} << 32 | cap;
ad->m_posAndCount = oldPosUnsigned;
if (UNLIKELY(strong_iterators_exist())) {
move_strong_iterators(ad, old);
}
// Steal the old array payload. At the time of this writing, it was
// better not to reuse the memcpy return value here because gcc had
// `ad' in a callee saved register anyway. The reg-to-reg move was
// smaller than subtracting sizeof(ArrayData) from rax to return.
old->m_size = 0;
std::memcpy(packedData(ad), packedData(old), oldSize * sizeof(TypedValue));
// TODO(#2926276): it would be good to refactor callers to expect
// our refcount to start at 1.
assert(ad->m_kind == ArrayData::kPackedKind);
assert(ad->m_pos == oldPos);
assert(ad->m_count == 0);
assert(ad->m_packedCap == cap);
assert(ad->m_size == oldSize);
assert(checkInvariants(ad));
return ad;
}
std::string Stats::debugString() const {
DEBUG_SINVARIANT(checkInvariants());
if (count() == 0) {
return "count 0";
} else {
return str(boost::format("count %d mean %G stddev %G var %G 95%%conf %G rel95%%conf %G"
" min %G max %G") % count() % mean() % stddev() % variance()
% conf95() % relconf95() % min() % max());
}
};
double StatsBase::stddev() const {
DEBUG_SINVARIANT(checkInvariants());
double sigsq = variance();
if (sigsq <= 0.0) {
return 0.0;
}
DEBUG_SINVARIANT(sigsq > 0.0);
return sqrt(sigsq);
}
std::string AliasIdSet::toString() const {
assertx(checkInvariants());
if (isBigInteger()) {
return folly::to<std::string>(m_bits);
}
if (empty()) return "None";
if (isAny()) return "Any";
std::string result;
// Try to print the slots by grouping them, expect output like
// '0~4,9,10,50~...'
auto first = true; // whether to avoid priting the separator
int32_t begin = -1; // starting bit of the consecutive range.
// Append slots [begin, end) to result string.
auto const appendRange = [&] (uint32_t end) {
assertx(end > begin);
result += folly::to<std::string>(begin);
if (end == begin + 1) return;
if (end == begin + 2) {
result += folly::to<std::string>(",", begin + 1);
} else {
result += folly::to<std::string>("~", end - 1);
}
};
for (uint32_t i = 0; i <= BitsetMax; ++i) {
if (test(i)) {
if (begin < 0) begin = static_cast<int32_t>(i);
else continue;
} else {
if (begin < 0) continue;
if (!first) result += ",";
appendRange(i);
begin = -1;
first = false;
}
}
if (hasUpperRange()) {
if (!first) result += ",";
if (begin < 0) begin = BitsetMax + 1;
result += folly::to<std::string>(begin, "~...");
} else if (begin >= 0) {
// Append [begin, BitsetMax].
appendRange(BitsetMax + 1);
}
return result;
}
void APCHandle::deleteShared() {
assert(checkInvariants());
switch (m_kind) {
case APCKind::Uninit:
case APCKind::Null:
case APCKind::Bool:
return;
case APCKind::Int:
case APCKind::Double:
case APCKind::StaticString:
case APCKind::StaticArray:
case APCKind::StaticVec:
case APCKind::StaticDict:
case APCKind::StaticKeyset:
delete APCTypedValue::fromHandle(this);
return;
case APCKind::SharedString:
case APCKind::SerializedArray:
case APCKind::SerializedVec:
case APCKind::SerializedDict:
case APCKind::SerializedKeyset:
case APCKind::SerializedObject:
APCString::Delete(APCString::fromHandle(this));
return;
case APCKind::SharedPackedArray:
case APCKind::SharedArray:
case APCKind::SharedVec:
case APCKind::SharedDict:
case APCKind::SharedKeyset:
APCArray::Delete(this);
return;
case APCKind::SharedObject:
APCObject::Delete(this);
return;
case APCKind::SharedCollection:
APCCollection::Delete(this);
return;
case APCKind::UncountedArray:
case APCKind::UncountedVec:
case APCKind::UncountedDict:
case APCKind::UncountedKeyset:
case APCKind::UncountedString:
assert(false);
return;
}
not_reached();
}
ArrayData* PackedArray::PlusEq(ArrayData* adIn, const ArrayData* elems) {
assert(checkInvariants(adIn));
auto const neededSize = adIn->size() + elems->size();
auto const mixed = ToMixedCopyReserve(adIn, neededSize);
try {
auto const ret = MixedArray::PlusEq(mixed, elems);
assert(ret == mixed);
assert(!mixed->hasMultipleRefs());
return ret;
} catch (...) {
MixedArray::Release(mixed);
throw;
}
}
ArrayData* PackedArray::RemoveInt(ArrayData* adIn, int64_t k, bool copy) {
assert(checkInvariants(adIn));
if (size_t(k) < adIn->m_size) {
// Escalate to mixed for correctness; unset preserves m_nextKI.
//
// TODO(#2606310): if we're removing the /last/ element, we
// probably could stay packed, but this needs to be verified.
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
auto pos = mixed->findForRemove(k, false);
if (validPos(pos)) mixed->erase(pos);
return mixed;
}
// Key doesn't exist---we're still packed.
return copy ? Copy(adIn) : adIn;
}
bool PackedArray::AdvanceMArrayIter(ArrayData* ad, MArrayIter& fp) {
assert(checkInvariants(ad));
if (fp.getResetFlag()) {
fp.setResetFlag(false);
fp.m_pos = ArrayData::invalid_index;
} else if (fp.m_pos == ArrayData::invalid_index) {
return false;
}
fp.m_pos = IterAdvance(ad, fp.m_pos);
if (fp.m_pos == ArrayData::invalid_index) {
return false;
}
// To conform to PHP behavior, we need to set the internal
// cursor to point to the next element.
ad->m_pos = IterAdvance(ad, fp.m_pos);
return true;
}
ArrayData* PackedArray::LvalNew(ArrayData* adIn, Variant*& ret, bool copy) {
assert(checkInvariants(adIn));
auto const ad = copy ? CopyAndResizeIfNeeded(adIn)
: ResizeIfNeeded(adIn);
if (UNLIKELY(!ad)) {
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(ad);
return MixedArray::LvalNew(mixed, ret, copy);
}
if (ad->m_pos == ArrayData::invalid_index) {
ad->m_pos = ad->m_size;
}
auto& tv = packedData(ad)[ad->m_size++];
tv.m_type = KindOfNull;
ret = &tvAsVariant(&tv);
return ad;
}
ArrayData* PackedArray::SetRefInt(ArrayData* adIn,
int64_t k,
Variant& v,
bool copy) {
assert(checkInvariants(adIn));
if (size_t(k) == adIn->m_size) return AppendRef(adIn, v, copy);
if (size_t(k) < adIn->m_size) {
auto const ad = copy ? Copy(adIn) : adIn;
tvBind(v.asRef(), &packedData(ad)[k]);
return ad;
}
// todo t2606310: key can't exist. use add/findForNewInsert
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
mixed->updateRef(k, v);
return mixed;
}
NEVER_INLINE
void PackedArray::Release(ArrayData* ad) {
assert(checkInvariants(ad));
assert(ad->isRefCounted());
auto const size = ad->m_size;
auto const data = packedData(ad);
auto const stop = data + size;
for (auto ptr = data; ptr != stop; ++ptr) {
tvRefcountedDecRef(*ptr);
}
if (UNLIKELY(strong_iterators_exist())) {
free_strong_iterators(ad);
}
auto const cap = ad->m_packedCap;
MM().objFreeLogged(ad, sizeof(ArrayData) + sizeof(TypedValue) * cap);
}
ArrayData* PackedArray::Append(ArrayData* adIn, const Variant& v, bool copy) {
assert(checkInvariants(adIn));
auto const ad = copy ? CopyAndResizeIfNeeded(adIn)
: ResizeIfNeeded(adIn);
if (UNLIKELY(!ad)) {
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
return MixedArray::Append(mixed, v, copy);
}
if (ad->m_pos == ArrayData::invalid_index) {
ad->m_pos = ad->m_size;
}
auto& dst = packedData(ad)[ad->m_size++];
cellDup(*v.asCell(), dst);
// TODO(#3888164): restructure this so we don't need KindOfUninit checks.
if (dst.m_type == KindOfUninit) dst.m_type = KindOfNull;
return ad;
}
AliasClass AliasClass::unionData(rep newBits, AliasClass a, AliasClass b) {
assertx(a.m_stag == b.m_stag);
switch (a.m_stag) {
case STag::None:
break;
case STag::Frame:
case STag::Prop:
case STag::ElemI:
case STag::ElemS:
case STag::MIState:
case STag::Ref:
assertx(!a.equivData(b));
break;
case STag::Stack:
{
auto const stkA = a.m_stack;
auto const stkB = b.m_stack;
// If two AStack have different bases, we can't union them any better
// than AStackAny, since we don't know where they are relative to each
// other. We know two AStacks with different FramePtr bases can't alias,
// but that doesn't help us represent a union of them.
if (stkA.base != stkB.base) return AliasClass{newBits};
// Make a stack range big enough to contain both of them.
auto const highest = std::max(stkA.offset, stkB.offset);
auto const lowest = std::min(lowest_offset(stkA), lowest_offset(stkB));
auto const newStack = AStack {
stkA.base,
highest,
highest - lowest
};
auto ret = AliasClass{newBits};
new (&ret.m_stack) AStack(newStack);
ret.m_stag = STag::Stack;
assertx(ret.checkInvariants());
assertx(a <= ret && b <= ret);
return ret;
}
}
return AliasClass{newBits};
}
VectorEpetra<T>::VectorEpetra ( Epetra_Vector const * v )
:
super( v->Map().NumGlobalElements(), v->Map().NumMyElements() ),
M_emap( v->Map() ),
M_vec ( M_emap )
{
this->init( M_emap, true );
//double** V;
//v->ExtractView(&V);
//printf("first val : %f\n",V[0][0]);
M_vec.Update( 1.0,*v,1.0 );
//for( size_type i = 0; i < this->localSize(); ++i )
// {
// this->set( i, V[ 0 ][i] );
// }
checkInvariants();
}
ArrayData* PackedArray::AppendWithRef(ArrayData* adIn,
const Variant& v,
bool copy) {
assert(checkInvariants(adIn));
auto const ad = copy ? CopyAndResizeIfNeeded(adIn)
: ResizeIfNeeded(adIn);
if (UNLIKELY(!ad)) {
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
// XXX: constness
return MixedArray::AppendRef(mixed, const_cast<Variant&>(v), copy);
}
if (ad->m_pos == ArrayData::invalid_index) {
ad->m_pos = ad->m_size;
}
auto& dst = packedData(ad)[ad->m_size++];
dst.m_type = KindOfNull;
tvAsVariant(&dst).setWithRef(v);
return ad;
}
ArrayData* PackedArray::AppendRef(ArrayData* adIn,
Variant& v,
bool copy) {
assert(checkInvariants(adIn));
auto const ad = copy ? CopyAndResizeIfNeeded(adIn)
: ResizeIfNeeded(adIn);
if (UNLIKELY(!ad)) {
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
return MixedArray::AppendRef(mixed, v, copy);
}
if (ad->m_pos == ArrayData::invalid_index) {
ad->m_pos = ad->m_size;
}
auto& dst = packedData(ad)[ad->m_size++];
dst.m_data.pref = v.asRef()->m_data.pref;
dst.m_type = KindOfRef;
dst.m_data.pref->incRefCount();
return ad;
}
void Stats::printRome(int depth, std::ostream &out) const {
DEBUG_SINVARIANT(checkInvariants());
std::string spaces;
for(int i = 0; i < depth; i++) {
spaces += " ";
}
out << spaces << "{ count " << countll() << " }\n";
if (count() > 0) {
out << spaces << "{ min " << min() << " }\n";
out << spaces << "{ max " << max() << " }\n";
out << spaces << "{ mean " << mean() << " }\n";
out << spaces << "{ stddev " << stddev() << " }\n";
out << spaces << "{ variance " << variance() << " }\n";
out << spaces << "{ conf95 " << conf95() << " }\n";
out << spaces << "{ total " << total() << " }\n";
out << spaces << "{ total_sq " << total_sq() << " }\n";
}
}
AliasIdSet AliasIdSet::operator|=(const AliasIdSet rhs) {
if (*this == rhs || rhs.empty()) return *this;
if (empty()) {
m_bits = rhs.m_bits;
return *this;
}
if (isBigInteger() || rhs.isBigInteger()) {
// Result contains a big integer, as well as one other integer, so we
// must use bitset mode.
setUpperRange();
}
if (rhs.isBitset()) {
// Both are bitsets.
m_bits |= rhs.m_bits;
}
assertx(checkInvariants());
return *this;
}
ArrayData* PackedArray::LvalInt(ArrayData* adIn,
int64_t k,
Variant*& ret,
bool copy) {
assert(checkInvariants(adIn));
if (LIKELY(size_t(k) < adIn->m_size)) {
auto const ad = copy ? Copy(adIn) : adIn;
ret = &tvAsVariant(&packedData(ad)[k]);
return ad;
}
// We can stay packed if the index is m_size, and the operation does
// the same thing as LvalNew.
if (size_t(k) == adIn->m_size) return LvalNew(adIn, ret, copy);
// Promote-to-mixed path, we know the key is new and should be using
// findForNewInsert but aren't yet TODO(#2606310).
auto const mixed = copy ? ToMixedCopy(adIn) : ToMixed(adIn);
return mixed->addLvalImpl(k, ret);
}
bool KisZoomAndPanTest::checkZoomWithWheel(ZoomAndPanTester &t, const QPoint &widgetPoint, qreal zoomCoeff, bool limitedZoom)
{
QPoint oldOffset = t.coordinatesConverter()->documentOffset();
QPointF oldPrefCenter = t.canvasController()->preferredCenter();
qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
QSize oldDocumentSize = t.canvasController()->documentSize();
t.canvasController()->zoomRelativeToPoint(widgetPoint, zoomCoeff);
QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
return checkInvariants(oldOffset + widgetPoint,
oldOffset,
oldPrefCenter,
oldZoom,
t.coordinatesConverter()->documentOffset(),
t.canvasController()->preferredCenter(),
limitedZoom ? oldZoom : zoomCoeff * oldZoom,
newTopLeft,
oldDocumentSize);
}
bool KisZoomAndPanTest::checkZoomWithAction(ZoomAndPanTester &t, qreal newZoom, bool limitedZoom)
{
QPoint oldOffset = t.coordinatesConverter()->documentOffset();
QPointF oldPrefCenter = t.canvasController()->preferredCenter();
qreal oldZoom = t.zoomController()->zoomAction()->effectiveZoom();
QSize oldDocumentSize = t.canvasController()->documentSize();
t.zoomController()->setZoom(KoZoomMode::ZOOM_CONSTANT, newZoom);
QPointF newTopLeft = t.coordinatesConverter()->imageRectInWidgetPixels().topLeft();
return checkInvariants(oldPrefCenter,
oldOffset,
oldPrefCenter,
oldZoom,
t.coordinatesConverter()->documentOffset(),
t.canvasController()->preferredCenter(),
limitedZoom ? oldZoom : newZoom,
newTopLeft,
oldDocumentSize);
}
MixedArray* StructArray::ToMixedCopy(const StructArray* old) {
auto const oldSize = old->size();
auto const ad = ToMixedHeader(oldSize + 1);
auto const srcData = old->data();
auto shape = old->shape();
memset(ad->hashTab(), static_cast<uint8_t>(MixedArray::Empty),
sizeof(int32_t) * ad->hashSize());
for (auto i = 0; i < oldSize; ++i) {
auto key = const_cast<StringData*>(shape->keyForOffset(i));
auto& e = ad->addKeyAndGetElem(key);
tvDupFlattenVars(&srcData[i], &e.data, old);
}
ad->m_pos = old->m_pos;
assert(ad->checkInvariants());
assert(!ad->isFull());
assert(ad->hasExactlyOneRef());
return ad;
}
