static int push_active_entry(struct xpmem_cmd_ringbuf * buf, struct xpmem_cmd_ex * cmd) { struct xpmem_cmd_entry * entry = NULL; unsigned long flags = 0; int start, end, ret = -1; spin_lock_irqsave(&(buf->lock), flags); start = buf->offset; end = (start == 0) ? MAX_CMDS - 1 : buf->offset - 1; while (buf->offset != end) { entry = &(buf->entries[buf->offset]); if (!entry->in_use) { entry->in_use = 1; entry->cmd = cmd; ret = 0; break; } buf->offset = next_offset(buf->offset); } spin_unlock_irqrestore(&(buf->lock), flags); return ret; }
void Boundary::iterate(OopVisitor* visitor) { Oop::iterate(visitor); { NamedField id("next", true); visitor->do_oop(&id, next_offset(), true); } }
static void pop_active_entry(struct xpmem_cmd_ringbuf * buf, struct xpmem_cmd_ex * cmd) { unsigned long flags = 0; int start, end; spin_lock_irqsave(&(buf->lock), flags); start = buf->offset; end = (start == 0) ? MAX_CMDS - 1 : buf->offset - 1; while (buf->offset != end) { struct xpmem_cmd_entry * entry = &(buf->entries[buf->offset]); if (entry->in_use) { memcpy(cmd, entry->cmd, sizeof(struct xpmem_cmd_ex)); kmem_free(entry->cmd); entry->in_use = 0; break; } buf->offset = next_offset(buf->offset); } spin_unlock_irqrestore(&(buf->lock), flags); }
void IsolateObj::verify_fields() { UsingFastOops fast_oops; InstanceClass::Fast ic = Universe::isolate_class(); ic().verify_instance_field("_next", "Lcom/sun/cldc/isolate/Isolate;", next_offset()); ic().verify_instance_field("_uniqueId", "J", unique_id_offset()); ic().verify_instance_field("_terminated","I", is_terminated_offset()); ic().verify_instance_field("_priority","I", priority_offset()); ic().verify_instance_field("_saved_exit_code","I", saved_exit_code_offset()); ic().verify_instance_field("_mainClass", "Ljava/lang/String;", main_class_offset()); ic().verify_instance_field("_mainArgs", "[Ljava/lang/String;", main_args_offset()); ic().verify_instance_field("_app_classpath", "[Ljava/lang/String;", app_classpath_offset()); ic().verify_instance_field("_sys_classpath", "[Ljava/lang/String;", sys_classpath_offset()); ic().verify_instance_field("_hidden_packages", "[Ljava/lang/String;", hidden_packages_offset()); ic().verify_instance_field("_restricted_packages", "[Ljava/lang/String;", restricted_packages_offset()); ic().verify_instance_field("_memoryReserve", "I", memory_reserve_offset()); ic().verify_instance_field("_memoryLimit", "I", memory_limit_offset()); ic().verify_instance_field("_profileId", "I", profile_id_offset()); }
void EntryActivation::iterate(OopVisitor* visitor) { #if USE_OOP_VISITOR Oop::iterate(visitor); { NamedField id("length", true); visitor->do_int(&id, length_offset(), true); } { NamedField id("method", true); visitor->do_oop(&id, method_offset(), true); } { NamedField id("next", true); visitor->do_oop(&id, next_offset(), true); } #if ENABLE_REFLECTION { NamedField id("return_point", true); id.set_hex_output(true); id.set_is_pointer(true); visitor->do_uint(&id, return_point_offset(), true); } #endif for (int index = 0; index < length(); index++) { IndexableField id(index, true); // visitor->do_int(&id, tag_offset(index), true); switch(tag_at(index)) { case float_tag: visitor->do_float(&id, value_offset(index), true); break; case obj_tag: visitor->do_oop(&id, value_offset(index), true); break; default: visitor->do_int(&id, value_offset(index), true); break; } } #endif }
BITBOTS_INLINE void KJoint::update_chain_masspoint_with_follower(const KJoint& next) { // I'm sorry for this complex confusing inline mass vector multiplication Vector next_offset((Vector()<<(get_right_transform(inverse, next) * (Vector()<<next.m_chain_masspoint.head<3>(), 1).finished()).head<3>(), next.m_chain_masspoint(3)).finished()); //Vector own_offset = (Vector() << m_mass_offset.head<3>() * m_mass_offset(3), m_mass_offset(3)).finished(); // When we consider the existing chain masspoint, we need 3 cols, 2 otherwise Eigen::Matrix<double, 4, 2> offsets; if(add_existing) offsets<<next_offset, m_chain_masspoint; else offsets<<next_offset, m_mass_offset; m_chain_masspoint = create_mass_offset(offsets); }
DataPageSlotIndex HashDataPage::reserve_record( HashValue hash, const BloomFilterFingerprint& fingerprint, const char* key, uint16_t key_length, uint16_t payload_length) { ASSERT_ND(header_.page_version_.is_locked()); ASSERT_ND(available_space() >= HashDataPage::required_space(key_length, payload_length)); DataPageSlotIndex index = get_record_count(); Slot& slot = get_slot(index); slot.offset_ = next_offset(); slot.hash_ = hash; slot.key_length_ = key_length; slot.physical_record_length_ = assorted::align8(key_length) + assorted::align8(payload_length); slot.payload_length_ = 0; char* record = record_from_offset(slot.offset_); std::memcpy(record, key, key_length); if (key_length % 8 != 0) { std::memset(record + key_length, 0, 8 - (key_length % 8)); } xct::XctId initial_id; initial_id.set( Epoch::kEpochInitialCurrent, // TODO(Hideaki) this should be something else 0); initial_id.set_deleted(); slot.tid_.xct_id_ = initial_id; // we install the fingerprint to bloom filter BEFORE we increment key count. // it's okay for concurrent reads to see false positives, but false negatives are wrong! bloom_filter_.add(fingerprint); // we increment key count AFTER installing the key because otherwise the optimistic read // might see the record but find that the key doesn't match. we need a fence to prevent it. assorted::memory_fence_release(); header_.increment_key_count(); return index; }
ReturnOop next(){ return obj_field(next_offset());}
void set_next(Oop * p) {obj_field_put(next_offset(), p);}
void clear_next() { obj_field_clear(next_offset()); }
void set_next(Thread* value) { obj_field_put(next_offset(), value); }
Plane findPlane(Axis a, BoundingVolume const &bv) { int off{ 0 }; int smallest{ std::numeric_limits<int>::max() }; Vec3 min{ bv.min() }; Vec3 max{ bv.min() + bv.extent() }; // move candidate plane along axis switch (a) { case Axis::X: { svt::accum_delta next_offset(min.x, svt::delta.x); int pp{ next_offset() }; while (pp < max.x) { int diff{ diffSides( min, { min.x+pp, max.y, max.z }, { min.x+pp, min.y, min.z }, max ) }; std::cout << "X pp: " << pp << " diff: " << diff << "\n-----\n" ; //TODO: handle diff==smallest separately if (diff <= smallest) { smallest = diff; off = pp; } pp = next_offset(); } //for return Plane{ { min.x + off, min.y, min.z }, { min.x + off, max.y, max.z } }; } case Axis::Y: { svt::accum_delta next_offset(min.y, svt::delta.y); int pp{ next_offset() }; while(pp < max.y) { int diff{ diffSides( min, { max.x, min.y+pp, max.z }, { min.x, min.y+pp, min.z }, max ) }; std::cout << "Y pp: " << pp << " diff: " << diff << "\n-----\n" ; //TODO: handle diff==smallest separately if (diff <= smallest) { smallest = diff; off = pp; } pp = next_offset(); } //for return Plane{ { min.x, min.y + off, min.z }, { max.x, min.y + off, max.z } }; } case Axis::Z: { svt::accum_delta next_offset(min.z, svt::delta.z); int pp{ next_offset() }; while (pp < max.z) { int diff{ diffSides( min, { max.x, max.y, min.z+pp }, { min.x, min.y, min.z+pp }, max ) }; std::cout << "Z pp: " << pp << " diff: " << diff << "\n-----\n" ; //TODO: handle diff==smallest separately if (diff <= smallest) { smallest = diff; off = pp; } pp = next_offset(); } //for return Plane{ { min.x, min.y, min.z + off }, { max.x, max.y, min.z + off } }; } default: break; } return Plane{ { -1,-1,-1 }, { -1,-1,-1 } }; // The most interesting case. }