PolytreeDE
/
alacritty
mirror of https://github.com/alacritty/alacritty.git
1
0
Fork 0
Code Releases Activity

Use memcpy for resetting row contents 

In addition to a marginal performance improvement, this simplifies some
logic in the Term implementation since now the Grid fully handles row
recycling.
This commit is contained in:
Joe Wilm 2018-01-14 10:17:08 -08:00
parent a88961bbf0
commit 350bb8c800
3 changed files with 87 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
src/grid/mod.rs
View File

@ -73,6 +73,15 @@ pub struct Grid<T> {
///
/// Invariant: lines is equivalent to raw.len()
lines: index::Line,
/// Template row.
///
/// This is used to quickly populate new lines and clear recycled lines
/// during scroll wrapping.
template_row: Row<T>,
/// Template cell for populating template_row
template: T,
}
pub struct GridIterator<'a, T: 'a> {
@ -80,55 +89,110 @@ pub struct GridIterator<'a, T: 'a> {
pub cur: Point,
}
impl<T: Clone> Grid<T> {
pub fn new(lines: index::Line, cols: index::Column, template: &T) -> Grid<T> {
impl<T: Copy + Clone> Grid<T> {
pub fn new(lines: index::Line, cols: index::Column, template: T) -> Grid<T> {
let mut raw = VecDeque::with_capacity(*lines);
let template_row = Row::new(cols, &template);
for _ in IndexRange(index::Line(0)..lines) {
raw.push_back(Row::new(cols, template));
raw.push_back(template_row.clone());
}
Grid {
raw,
cols,
lines,
template_row,
template,
}
}
pub fn resize(&mut self, lines: index::Line, cols: index::Column, template: &T) {
pub fn resize(&mut self, lines: index::Line, cols: index::Column) {
// Check that there's actually work to do and return early if not
if lines == self.lines && cols == self.cols {
return;
}
match self.lines.cmp(&lines) {
Ordering::Less => self.grow_lines(lines, template),
Ordering::Less => self.grow_lines(lines),
Ordering::Greater => self.shrink_lines(lines),
Ordering::Equal => (),
}
match self.cols.cmp(&cols) {
Ordering::Less => self.grow_cols(cols, template),
Ordering::Less => self.grow_cols(cols),
Ordering::Greater => self.shrink_cols(cols),
Ordering::Equal => (),
}
}
fn grow_lines(&mut self, lines: index::Line, template: &T) {
fn grow_lines(&mut self, lines: index::Line) {
for _ in IndexRange(self.num_lines()..lines) {
self.raw.push_back(Row::new(self.cols, template));
self.raw.push_back(self.template_row.clone());
}
self.lines = lines;
}
fn grow_cols(&mut self, cols: index::Column, template: &T) {
fn grow_cols(&mut self, cols: index::Column) {
for row in self.raw.iter_mut() {
row.grow(cols, template);
row.grow(cols, &self.template);
}
// Update self cols
self.cols = cols;
// Also update template_row to be the correct length
self.template_row.grow(cols, &self.template);
}
#[inline]
pub fn scroll_down(&mut self, region: &Range<index::Line>, positions: index::Line) {
if region.start == Line(0) && region.end == self.num_lines() {
// Full rotation
for _ in 0..positions.0 {
let mut item = self.raw.pop_back().unwrap();
item.reset(&self.template_row);
self.raw.push_front(item);
}
} else {
// Subregion rotation
for line in IndexRange((region.start + positions)..region.end).rev() {
self.swap_lines(line, line - positions);
}
let template = &self.template_row;
for i in IndexRange(Line(0)..positions) {
self.raw
.get_mut(*(region.start + i))
.map(|row| row.reset(template));
}
}
}
#[inline]
pub fn scroll_up(&mut self, region: &Range<index::Line>, positions: index::Line) {
if region.start == Line(0) && region.end == self.num_lines() {
// Full rotation
for _ in 0..positions.0 {
let mut item = self.raw.pop_front().unwrap();
item.reset(&self.template_row);
self.raw.push_back(item);
}
} else {
// Subregion rotation
for line in IndexRange(region.start..(region.end - positions)) {
self.swap_lines(line, line + positions);
}
// Clear reused lines
let template = &self.template_row;
for i in IndexRange(Line(0)..positions) {
self.raw
.get_mut(*(region.end - i - 1))
.map(|row| row.reset(template));
}
}
}
}
impl<T> Grid<T> {
@ -142,38 +206,6 @@ impl<T> Grid<T> {
self.cols
}
#[inline]
pub fn scroll_down(&mut self, region: &Range<index::Line>, positions: index::Line) {
if region.start == Line(0) && region.end == self.num_lines() {
// Full rotation
for _ in 0..positions.0 {
let item = self.raw.pop_back().unwrap();
self.raw.push_front(item);
}
} else {
// Subregion rotation
for line in IndexRange((region.start + positions)..region.end).rev() {
self.swap_lines(line, line - positions);
}
}
}
#[inline]
pub fn scroll_up(&mut self, region: &Range<index::Line>, positions: index::Line) {
if region.start == Line(0) && region.end == self.num_lines() {
// Full rotation
for _ in 0..positions.0 {
let item = self.raw.pop_front().unwrap();
self.raw.push_back(item);
}
} else {
// Subregion rotation
for line in IndexRange(region.start..(region.end - positions)) {
self.swap_lines(line, line + positions);
}
}
}
pub fn iter_from(&self, point: Point) -> GridIterator<T> {
GridIterator {
grid: self,
@ -209,6 +241,7 @@ impl<T> Grid<T> {
}
self.cols = cols;
self.template_row.shrink(cols);
}
}

12
src/grid/row.rs
View File

@ -24,16 +24,22 @@ use index::Column;
#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct Row<T>(Vec<T>);
impl<T: Clone> Row<T> {
impl<T: Copy + Clone> Row<T> {
pub fn new(columns: Column, template: &T) -> Row<T> {
Row(vec![template.to_owned(); *columns])
Row(vec![*template; *columns])
}
pub fn grow(&mut self, cols: Column, template: &T) {
while self.len() != *cols {
self.push(template.to_owned());
self.push(*template);
}
}
/// Resets contents to the contents of `other`
#[inline]
pub fn reset(&mut self, other: &Row<T>) {
self.copy_from_slice(&**other);
}
}
impl<T> Row<T> {

27
src/term/mod.rs
View File

@ -800,7 +800,7 @@ impl Term {
let num_cols = size.cols();
let num_lines = size.lines();
let grid = Grid::new(num_lines, num_cols, &template);
let grid = Grid::new(num_lines, num_cols, template);
let tabspaces = config.tabspaces();
let tabs = IndexRange::from(Column(0)..grid.num_cols())
@ -1066,9 +1066,8 @@ impl Term {
debug!("num_cols, num_lines = {}, {}", num_cols, num_lines);
// Resize grids to new size
let template = Cell::default();
self.grid.resize(num_lines, num_cols, &template);
self.alt_grid.resize(num_lines, num_cols, &template);
self.grid.resize(num_lines, num_cols);
self.alt_grid.resize(num_lines, num_cols);
// Reset scrolling region to new size
self.scroll_region = Line(0)..self.grid.num_lines();
@ -1133,17 +1132,6 @@ impl Term {
trace!("scroll_down_relative: origin={}, lines={}", origin, lines);
let lines = min(lines, self.scroll_region.end - self.scroll_region.start);
// Copy of cell template; can't have it borrowed when calling clear/scroll
let template = self.cursor.template;
// Clear `lines` lines at bottom of area
{
let start = max(origin, Line(self.scroll_region.end.0.saturating_sub(lines.0)));
self.grid
.region_mut(start..self.scroll_region.end)
.each(|c| c.reset(&template));
}
// Scroll between origin and bottom
self.grid.scroll_down(&(origin..self.scroll_region.end), lines);
}
@ -1157,15 +1145,6 @@ impl Term {
trace!("scroll_up_relative: origin={}, lines={}", origin, lines);
let lines = min(lines, self.scroll_region.end - self.scroll_region.start);
// Copy of cell template; can't have it borrowed when calling clear/scroll
let template = self.cursor.template;
// Clear `lines` lines starting from origin to origin + lines
{
let end = min(origin + lines, self.scroll_region.end);
self.grid.region_mut(origin..end).each(|c| c.reset(&template));
}
// Scroll from origin to bottom less number of lines
self.grid.scroll_up(&(origin..self.scroll_region.end), lines);
}