Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
void Boundary::iterate(OopVisitor* visitor) {
  Oop::iterate(visitor);
  { 
    NamedField id("next", true);
    visitor->do_oop(&id, next_offset(), true);
  }
}
Exemplo n.º 3
0
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);
}
Exemplo n.º 4
0
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()); 
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 7
0
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;
}
Exemplo n.º 8
0
 ReturnOop next(){ return obj_field(next_offset());}
Exemplo n.º 9
0
 void set_next(Oop * p) {obj_field_put(next_offset(), p);}
Exemplo n.º 10
0
 void clear_next() {
   obj_field_clear(next_offset());
 }
Exemplo n.º 11
0
 void set_next(Thread* value) {
   obj_field_put(next_offset(), value);
 }
Exemplo n.º 12
0
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.
}