Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-07 06:25:32 +01:00
Code Issues Projects Releases Packages Wiki Activity

Add some timing info, update rust-azure to fix crash

Browse source
This commit is contained in:
Patrick Walton 2012-11-09 19:10:51 -08:00
parent 4303419865
commit b1c59aba61
2 changed files with 74 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/rust-azure

@ -1 +1 @@
Subproject commit 385867116d04f5d4aa34976bf9794bcb1913f162 Subproject commit 55457bba7f6a07728518a7a8f33b140bc72a51d7

143
src/servo/gfx/render_layers.rs
View file

@ -1,6 +1,7 @@
use gfx::display_list::DisplayList; use gfx::display_list::DisplayList;
use gfx::compositor::{LayerBuffer, LayerBufferSet}; use gfx::compositor::{LayerBuffer, LayerBufferSet};
use opts::Opts; use opts::Opts;
use util::time;
use azure::AzFloat; use azure::AzFloat;
use azure::azure_hl::{B8G8R8A8, DrawTarget}; use azure::azure_hl::{B8G8R8A8, DrawTarget};
@ -38,95 +39,97 @@ pub fn render_layers(layer_ref: *RenderLayer,
let new_buffer_ports = dvec::DVec(); let new_buffer_ports = dvec::DVec();
// Divide up the layer into tiles. // Divide up the layer into tiles.
let layer: &RenderLayer = unsafe { cast::transmute(layer_ref) }; do time::time("rendering: preparing buffers") {
let mut y = 0; let layer: &RenderLayer = unsafe { cast::transmute(layer_ref) };
while y < layer.size.height { let mut y = 0;
let mut x = 0; while y < layer.size.height {
while x < layer.size.width { let mut x = 0;
// Figure out the dimension of this tile. while x < layer.size.width {
let right = uint::min(x + TILE_SIZE, layer.size.width); // Figure out the dimension of this tile.
let bottom = uint::min(y + TILE_SIZE, layer.size.height); let right = uint::min(x + TILE_SIZE, layer.size.width);
let width = right - x; let bottom = uint::min(y + TILE_SIZE, layer.size.height);
let height = bottom - y; let width = right - x;
let height = bottom - y;
// Round the width up the nearest 32 pixels for DMA on the Mac. // Round the width up the nearest 32 pixels for DMA on the Mac.
let mut stride = width; let mut stride = width;
if stride % 32 != 0 { if stride % 32 != 0 {
stride = (stride & !(32 - 1)) + 32; stride = (stride & !(32 - 1)) + 32;
} }
assert stride % 32 == 0; assert stride % 32 == 0;
assert stride >= width; assert stride >= width;
debug!("tile stride %u", stride); debug!("tile stride %u", stride);
let tile_rect = Rect(Point2D(x, y), Size2D(width, height)); let tile_rect = Rect(Point2D(x, y), Size2D(width, height));
let buffer; let buffer;
// FIXME: Try harder to search for a matching tile. // FIXME: Try harder to search for a matching tile.
// FIXME: Don't use shift; it's bad for perf. Maybe reverse and pop. // FIXME: Don't use shift; it's bad for perf. Maybe reverse and pop.
/*if buffers.len() != 0 && buffers[0].rect == tile_rect { /*if buffers.len() != 0 && buffers[0].rect == tile_rect {
debug!("reusing tile, (%u, %u)", x, y); debug!("reusing tile, (%u, %u)", x, y);
buffer = buffers.shift(); buffer = buffers.shift();
} else {*/ } else {*/
// Create a new buffer. // Create a new buffer.
debug!("creating tile, (%u, %u)", x, y); debug!("creating tile, (%u, %u)", x, y);
let size = Size2D(stride as i32, height as i32); let size = Size2D(stride as i32, height as i32);
let mut data: ~[u8] = ~[0]; let mut data: ~[u8] = ~[0];
let offset; let offset;
unsafe { unsafe {
// FIXME: Evil black magic to ensure that we don't perform a slow memzero // FIXME: Evil black magic to ensure that we don't perform a slow memzero
// of this buffer. This should be made safe. // of this buffer. This should be made safe.
let align = 256; let align = 256;
let len = ((size.width * size.height * 4) as uint) + align; let len = ((size.width * size.height * 4) as uint) + align;
vec::reserve(&mut data, len); vec::reserve(&mut data, len);
vec::raw::set_len(&mut data, len); vec::raw::set_len(&mut data, len);
// Round up to the nearest 32-byte-aligned address for DMA on the Mac. // Round up to the nearest 32-byte-aligned address for DMA on the Mac.
let addr: uint = cast::transmute(ptr::to_unsafe_ptr(&data[0])); let addr: uint = cast::transmute(ptr::to_unsafe_ptr(&data[0]));
if addr % align == 0 { if addr % align == 0 {
offset = 0; offset = 0;
} else { } else {
offset = align - addr % align; offset = align - addr % align;
}
debug!("tile offset is %u, expected addr is %x", offset, addr + offset);
} }
debug!("tile offset is %u, expected addr is %x", offset, addr + offset); buffer = LayerBuffer {
} draw_target: DrawTarget::new_with_data(opts.render_backend,
move data,
offset,
size,
size.width * 4,
B8G8R8A8),
rect: tile_rect,
stride: stride
};
//}
buffer = LayerBuffer { // Create a port and channel pair to receive the new buffer.
draw_target: DrawTarget::new_with_data(opts.render_backend, let (new_buffer_chan, new_buffer_port) = pipes::stream();
move data,
offset,
size,
size.width * 4,
B8G8R8A8),
rect: tile_rect,
stride: stride
};
//}
// Create a port and channel pair to receive the new buffer. // Send the buffer to the child.
let (new_buffer_chan, new_buffer_port) = pipes::stream(); f(layer_ref, move buffer, move new_buffer_chan);
// Send the buffer to the child. // Enqueue the port.
// FIXME: Don't copy the RenderLayer. new_buffer_ports.push(move new_buffer_port);
f(layer_ref, move buffer, move new_buffer_chan);
// Enqueue the port. x += TILE_SIZE;
new_buffer_ports.push(move new_buffer_port); }
y += TILE_SIZE;
x += TILE_SIZE;
} }
y += TILE_SIZE;
} }
debug!("servo::gfx::render_layers: waiting on ports...");
let new_buffers = dvec::DVec(); let new_buffers = dvec::DVec();
for new_buffer_ports.each |new_buffer_port| { do time::time("rendering: waiting on subtasks") {
new_buffers.push(new_buffer_port.recv()); for new_buffer_ports.each |new_buffer_port| {
new_buffers.push(new_buffer_port.recv());
}
} }
return LayerBufferSet { buffers: move dvec::unwrap(move new_buffers) }; return LayerBufferSet { buffers: move dvec::unwrap(move new_buffers) };