void push(const char* scope)
{
ticket_type last = top();
ticket_type t = 0;
if (last) {
t = m_tracer->push(last, scope);
} else {
t = m_tracer->push(m_tracer->root(), scope);
}
set_top(t);
}
// This version requires locking.
inline HeapWord* G1OffsetTableContigSpace::allocate_impl(size_t size,
HeapWord* const end_value) {
HeapWord* obj = top();
if (pointer_delta(end_value, obj) >= size) {
HeapWord* new_top = obj + size;
set_top(new_top);
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
return obj;
} else {
return NULL;
}
}
bool PSPromotionLAB::unallocate_object(HeapWord* obj, size_t obj_size) {
assert(ParallelScavengeHeap::heap()->is_in(obj), "Object outside heap");
if (contains(obj)) {
HeapWord* object_end = obj + obj_size;
assert(object_end == top(), "Not matching last allocation");
set_top(obj);
return true;
}
return false;
}
// This version requires locking.
inline HeapWord* ContiguousSpace::allocate_impl(size_t size) {
assert(Heap_lock->owned_by_self() ||
(SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()),
"not locked");
HeapWord* obj = top();
if (pointer_delta(end(), obj) >= size) {
HeapWord* new_top = obj + size;
set_top(new_top);
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
return obj;
} else {
return NULL;
}
}
css_error css__compose_top(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed length = 0;
css_unit unit = CSS_UNIT_PX;
uint8_t type = get_top(child, &length, &unit);
if (type == CSS_TOP_INHERIT) {
type = get_top(parent, &length, &unit);
}
return set_top(result, type, length, unit);
}
// This version requires locking.
inline HeapWord* ContiguousSpace::allocate_impl(size_t size,
HeapWord* const end_value) {
assert(Heap_lock.owned_by_self()||
(SafepointSynchronize::is_at_safepoint() &&
Thread::current()->is_VM_thread()),
"not locked");
HeapWord* obj = top();
if (pointer_delta(end_value, obj) >= size) {
HeapWord* new_top = obj + size;
set_top(new_top);
return obj;
} else {
return NULL;
}
}
ptr<pub3::expr_dict_t>
json_encoder_t::top_dict ()
{
ptr<pub3::expr_dict_t> ret;
ptr<pub3::expr_t> &back = m_obj_stack.back ();
if (!back) {
ret = pub3::expr_dict_t::alloc ();
back = ret;
set_top (ret);
} else {
ret = back->to_dict ();
assert (ret);
}
return ret;
}
bool PSPromotionLAB::unallocate_object(oop obj) {
assert(Universe::heap()->is_in(obj), "Object outside heap");
if (contains(obj)) {
HeapWord* object_end = (HeapWord*)obj + obj->size();
assert(object_end <= top(), "Object crosses promotion LAB boundary");
if (object_end == top()) {
set_top((HeapWord*)obj);
return true;
}
}
return false;
}
// Fills the current tlab with a dummy filler array to create
// an illusion of a contiguous Eden and optionally retires the tlab.
// Waste accounting should be done in caller as appropriate; see,
// for example, clear_before_allocation().
void ThreadLocalAllocBuffer::make_parsable(bool retire) {
if (end() != NULL) {
invariants();
CollectedHeap::fill_with_object(top(), hard_end());
if (retire || ZeroTLAB) { // "Reset" the TLAB
set_start(NULL);
set_top(NULL);
set_pf_top(NULL);
set_end(NULL);
}
}
assert(!(retire || ZeroTLAB) ||
(start() == NULL && end() == NULL && top() == NULL),
"TLAB must be reset");
}
void HeapRegion::clear_humongous() {
assert(isHumongous(), "pre-condition");
if (startsHumongous()) {
assert(top() <= end(), "pre-condition");
set_end(_orig_end);
if (top() > end()) {
// at least one "continues humongous" region after it
set_top(end());
}
} else {
// continues humongous
assert(end() == _orig_end, "sanity");
}
assert(capacity() == HeapRegion::GrainBytes, "pre-condition");
_humongous_start_region = NULL;
}
// This version requires locking.
inline HeapWord* ContiguousSpace::allocate_impl(size_t size,
HeapWord* const end_value) {
// In G1 there are places where a GC worker can allocates into a
// region using this serial allocation code without being prone to a
// race with other GC workers (we ensure that no other GC worker can
// access the same region at the same time). So the assert below is
// too strong in the case of G1.
assert(Heap_lock->owned_by_self() ||
(SafepointSynchronize::is_at_safepoint() &&
(Thread::current()->is_VM_thread() || UseG1GC)),
"not locked");
HeapWord* obj = top();
if (pointer_delta(end_value, obj) >= size) {
HeapWord* new_top = obj + size;
set_top(new_top);
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
return obj;
} else {
return NULL;
}
}
IntrusiveAllocator(void* begin, void* end) :
EmbeddedAllocator{begin, end, sizeof(void*)}
{
/*
* Pool layout:
*
* metadata storage
* <---------> <------------------>
* +-----+-----+--------------------+
* | end | top | ... |
* +-----+-----+--------------------+
* ^ ^ ^
* | | |
* begin top end
*
* <------------>
* storage used
*
*/
set_top(EmbeddedAllocator::begin());
}
void* allocate(std::size_t size, std::size_t alignment, std::size_t offset = 0)
{
assert(offset == 0 && "Cannot do offsetting with this allocator, it stores metadata before user block-address");
offset = sizeof(offset_t);
char* user_ptr = detail::aligned_ptr(top() + offset, alignment);
char* block_end = user_ptr + size;
if (block_end <= end())
{
// Store padding length between current top and returned (user) ptr
detail::write_before(user_ptr, static_cast<offset_t>(user_ptr - top()));
set_top(block_end);
return user_ptr;
}
else
{
return nullptr;
}
}
/**
* 从当前线程的本地分配缓冲区中分配指定大小的内存块
*/
inline HeapWord* ThreadLocalAllocBuffer::allocate(size_t size) {
invariants();
HeapWord* obj = top();
if (pointer_delta(end(), obj) >= size) { //缓冲区的空闲内存足够本次分配
// successful thread-local allocation
#ifdef ASSERT
// Skip mangling the space corresponding to the object header to
// ensure that the returned space is not considered parsable by
// any concurrent GC thread.
size_t hdr_size = oopDesc::header_size();
Copy::fill_to_words(obj + hdr_size, size - hdr_size, badHeapWordVal);
#endif // ASSERT
//重置缓冲区分配内存的开始位置
set_top(obj + size);
invariants();
return obj;
}
return NULL;
}
MirWaitHandle* MirSurface::modify(MirSurfaceSpec const& spec)
{
mp::SurfaceModifications mods;
{
std::unique_lock<decltype(mutex)> lock(mutex);
mods.mutable_surface_id()->set_value(surface->id().value());
}
auto const surface_specification = mods.mutable_surface_specification();
#define COPY_IF_SET(field)\
if (spec.field.is_set())\
surface_specification->set_##field(spec.field.value())
COPY_IF_SET(width);
COPY_IF_SET(height);
COPY_IF_SET(pixel_format);
COPY_IF_SET(buffer_usage);
// name is a special case (below)
COPY_IF_SET(output_id);
COPY_IF_SET(type);
COPY_IF_SET(state);
// preferred_orientation is a special case (below)
// parent_id is a special case (below)
// aux_rect is a special case (below)
COPY_IF_SET(edge_attachment);
COPY_IF_SET(min_width);
COPY_IF_SET(min_height);
COPY_IF_SET(max_width);
COPY_IF_SET(max_height);
COPY_IF_SET(width_inc);
COPY_IF_SET(height_inc);
// min_aspect is a special case (below)
// max_aspect is a special case (below)
#undef COPY_IF_SET
if (spec.surface_name.is_set())
surface_specification->set_name(spec.surface_name.value());
if (spec.pref_orientation.is_set())
surface_specification->set_preferred_orientation(spec.pref_orientation.value());
if (spec.parent.is_set() && spec.parent.value())
surface_specification->set_parent_id(spec.parent.value()->id());
if (spec.parent_id)
{
auto id = surface_specification->mutable_parent_persistent_id();
id->set_value(spec.parent_id->as_string());
}
if (spec.aux_rect.is_set())
{
auto const rect = surface_specification->mutable_aux_rect();
auto const& value = spec.aux_rect.value();
rect->set_left(value.left);
rect->set_top(value.top);
rect->set_width(value.width);
rect->set_height(value.height);
}
if (spec.min_aspect.is_set())
{
auto const aspect = surface_specification->mutable_min_aspect();
aspect->set_width(spec.min_aspect.value().width);
aspect->set_height(spec.min_aspect.value().height);
}
if (spec.max_aspect.is_set())
{
auto const aspect = surface_specification->mutable_max_aspect();
aspect->set_width(spec.max_aspect.value().width);
aspect->set_height(spec.max_aspect.value().height);
}
if (spec.streams.is_set())
{
auto_resize_stream = false;
for(auto const& stream : spec.streams.value())
{
auto const new_stream = surface_specification->add_stream();
new_stream->set_displacement_x(stream.displacement_x);
new_stream->set_displacement_y(stream.displacement_y);
new_stream->mutable_id()->set_value(
reinterpret_cast<mcl::ClientBufferStream*>(stream.stream)->rpc_id().as_value());
}
}
if (spec.input_shape.is_set())
{
for (auto const& rect : spec.input_shape.value())
{
auto const new_shape = surface_specification->add_input_shape();
new_shape->set_left(rect.left);
new_shape->set_top(rect.top);
new_shape->set_width(rect.width);
new_shape->set_height(rect.height);
}
}
modify_wait_handle.expect_result();
server->modify_surface(&mods, modify_result.get(),
google::protobuf::NewCallback(this, &MirSurface::on_modified));
return &modify_wait_handle;
}
/// \brief Set the top right corner
constexpr void set_top_right(point< position_type > const& topRight){
set_top(topRight.x);
set_right(topRight.y);
}
css_error css__set_top_from_hint(const css_hint *hint,
css_computed_style *style)
{
return set_top(style, hint->status,
hint->data.length.value, hint->data.length.unit);
}
void decommit(std::size_t bytes)
{
set_top(top() - bytes);
}
void commit(std::size_t bytes)
{
set_top(top() + bytes);
}
bool
json_encoder_t::rpc_traverse (u_int64_t &obj)
{
set_top (pub3::expr_uint_t::alloc (obj));
return true;
}
void G1OffsetTableContigSpace::clear(bool mangle_space) {
set_top(bottom());
_scan_top = bottom();
CompactibleSpace::clear(mangle_space);
reset_bot();
}
static void stack_push(struct except_stacknode *node)
{
node->except_down = get_top();
set_top(node);
}
TITANIUM_PROPERTY_SETTER(Animation, top)
{
TITANIUM_ASSERT(argument.IsNumber());
set_top(static_cast<double>(argument));
return true;
}
bool
json_encoder_t::rpc_encode (str s)
{
set_top (pub3::expr_str_t::alloc (s));
return true;
}
bool
json_encoder_t::rpc_traverse_null()
{
set_top (pub3::expr_null_t::alloc ());
return true;
}
void ContiguousSpace::clear(bool mangle_space) {
set_top(bottom());
set_saved_mark();
CompactibleSpace::clear(mangle_space);
}
css_error css__initial_top(css_select_state *state)
{
return set_top(state->computed, CSS_TOP_AUTO, 0, CSS_UNIT_PX);
}
int main()
{
create_connect();
init_servo();
//light_it_up(LIGHT_PORT);
lightstart(LIGHT_PORT,120.0);
create_full();
create_drive_segment(HIGH_SPEED, -150);
start_process(set_top);
create_drive_arc(HIGH_SPEED, -200, 155);
create_drive_segment(HIGH_SPEED, -365);
create_drive_arc(HIGH_SPEED, 90, -64);
create_drive_segment(HIGH_SPEED, -85);
create_cease();
set_top();
align_twall();
grab_top_de();
create_spin_angle(400,-165);
create_drive_segment(HIGH_SPEED, -320);
//align_wall();
create_stop();
create_sync();
dump_kelp_de();
create_drive_segment(HIGH_SPEED,30);//go away from starting box
create_spin_angle(HIGH_SPEED, -78);//turn to gate part 1
create_drive_segment(HIGH_SPEED, 938);//go to gate
create_drive_arc(HIGH_SPEED,185,84);//arc to gate
//create_drive_time(HIGH_SPEED,1800);//go through the gate
/*
create_drive_segment(HIGH_SPEED,1470);
create_drive_segment(HIGH_SPEED,-100);
create_spin_angle(HIGH_SPEED,78);
*/
create_cease();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(2000);
create_stop();
create_arc(400,400);//arc to the opponent's mpa
msleep(7000L);
create_stop();//pause to keep the creat
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
create_drive_straight(-HIGH_SPEED);//go onto oppponent's side of board
msleep(500);
create_stop();
/*
create_drive_segment(500,-500);//go past the IC
create_drive_arc(320,-250,25);//arc to
create_drive_arc(320,250,-8);
*/
//create_drive_segment(HIGH_SPEED,-750);
//create_drive_arc(HIGH_SPEED,100,84);
//create_drive_segment(HIGH_SPEED,1300);
}
struct except_stacknode *except_pop(void)
{
struct except_stacknode *top = get_top();
set_top(top->except_down);
return top;
}
rect& rect::set_pos(int x, int y)
{
set_left(x);
set_top(y);
return *this;
}
