rishi/scryer-prolog
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format code using 'cargo fmt'

Browse Source
This commit is contained in:
Atul Bhosale
2019-09-23 19:35:37 +07:00
parent 8207fdea40
commit 1273e2d52d
36 changed files with 8738 additions and 6375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
src/prolog/debray_allocator.rs
View File

@@ -3,8 +3,8 @@ use indexmap::IndexMap;
use prolog_parser::ast::*;
use prolog::allocator::*;
use prolog::forms::*;
use prolog::fixtures::*;
use prolog::forms::*;
use prolog::machine::machine_indices::*;
use prolog::targets::*;
@@ -14,27 +14,25 @@ use std::rc::Rc;
pub struct DebrayAllocator {
bindings: IndexMap<Rc<Var>, VarData>,
arg_c: usize,
temp_lb: usize,
arity: usize, // 0 if not at head.
arg_c: usize,
temp_lb: usize,
arity: usize, // 0 if not at head.
contents: IndexMap<usize, Rc<Var>>,
in_use: BTreeSet<usize>,
in_use: BTreeSet<usize>,
}
impl DebrayAllocator {
fn is_curr_arg_distinct_from(&self, var: &Var) -> bool {
match self.contents.get(&self.arg_c) {
Some(t_var) if **t_var != *var => true,
_ => false
_ => false,
}
}
fn occurs_shallowly_in_head(&self, var: &Var, r: usize) -> bool
{
fn occurs_shallowly_in_head(&self, var: &Var, r: usize) -> bool {
match self.bindings.get(var).unwrap() {
&VarData::Temp(_, _, ref tvd) =>
tvd.use_set.contains(&(GenContext::Head, r)),
_ => false
&VarData::Temp(_, _, ref tvd) => tvd.use_set.contains(&(GenContext::Head, r)),
_ => false,
}
}
@@ -44,8 +42,7 @@ impl DebrayAllocator {
in_use_range || self.in_use.contains(&r)
}
fn alloc_with_cr(&self, var: &Var) -> usize
{
fn alloc_with_cr(&self, var: &Var) -> usize {
match self.bindings.get(var) {
Some(&VarData::Temp(_, _, ref tvd)) => {
for &(_, reg) in tvd.use_set.iter() {
@@ -56,7 +53,7 @@ impl DebrayAllocator {
let mut result = 0;
for reg in self.temp_lb .. {
for reg in self.temp_lb.. {
if !self.is_in_use(reg) {
if !tvd.no_use_set.contains(&reg) {
result = reg;
@@ -66,13 +63,12 @@ impl DebrayAllocator {
}
result
},
_ => 0
}
_ => 0,
}
}
fn alloc_with_ca(&self, var: &Var) -> usize
{
fn alloc_with_ca(&self, var: &Var) -> usize {
match self.bindings.get(var) {
Some(&VarData::Temp(_, _, ref tvd)) => {
for &(_, reg) in tvd.use_set.iter() {
@@ -83,7 +79,7 @@ impl DebrayAllocator {
let mut result = 0;
for reg in self.temp_lb .. {
for reg in self.temp_lb.. {
if !self.is_in_use(reg) {
if !tvd.no_use_set.contains(&reg) {
if !tvd.conflict_set.contains(&reg) {
@@ -95,13 +91,12 @@ impl DebrayAllocator {
}
result
},
_ => 0
}
_ => 0,
}
}
fn alloc_in_last_goal_hint(&self, chunk_num: usize) -> Option<(Rc<Var>, usize)>
{
fn alloc_in_last_goal_hint(&self, chunk_num: usize) -> Option<(Rc<Var>, usize)> {
// we want to allocate a register to the k^{th} parameter, par_k.
// par_k may not be a temporary variable.
let k = self.arg_c;
@@ -121,13 +116,14 @@ impl DebrayAllocator {
}
None
},
_ => None
}
_ => None,
}
}
fn evacuate_arg<'a, Target>(&mut self, chunk_num: usize, target: &mut Vec<Target>)
where Target: CompilationTarget<'a>
where
Target: CompilationTarget<'a>,
{
match self.alloc_in_last_goal_hint(chunk_num) {
Some((var, r)) => {
@@ -144,42 +140,47 @@ impl DebrayAllocator {
self.record_register(var, r);
self.in_use.insert(r.reg_num());
}
},
}
_ => {}
};
}
fn alloc_reg_to_var<'a, Target>(&mut self, var: &Var, lvl: Level, term_loc: GenContext,
target: &mut Vec<Target>)
-> usize
where Target: CompilationTarget<'a>
fn alloc_reg_to_var<'a, Target>(
&mut self,
var: &Var,
lvl: Level,
term_loc: GenContext,
target: &mut Vec<Target>,
) -> usize
where
Target: CompilationTarget<'a>,
{
match term_loc {
GenContext::Head =>
GenContext::Head => {
if let Level::Shallow = lvl {
self.evacuate_arg(0, target);
self.alloc_with_cr(var)
} else {
self.alloc_with_ca(var)
},
GenContext::Mid(_) =>
self.alloc_with_ca(var),
GenContext::Last(chunk_num) =>
}
}
GenContext::Mid(_) => self.alloc_with_ca(var),
GenContext::Last(chunk_num) => {
if let Level::Shallow = lvl {
self.evacuate_arg(chunk_num, target);
self.alloc_with_cr(var)
} else {
self.alloc_with_ca(var)
}
}
}
}
fn alloc_reg_to_non_var(&mut self) -> usize
{
fn alloc_reg_to_non_var(&mut self) -> usize {
let mut final_index = 0;
for index in self.temp_lb .. {
if !self.in_use.contains(&index) {
for index in self.temp_lb.. {
if !self.in_use.contains(&index) {
final_index = index;
break;
}
@@ -190,33 +191,32 @@ impl DebrayAllocator {
final_index
}
fn in_place(&self, var: &Var, term_loc: GenContext, r: RegType, k: usize) -> bool
{
fn in_place(&self, var: &Var, term_loc: GenContext, r: RegType, k: usize) -> bool {
match term_loc {
GenContext::Head if !r.is_perm() => r.reg_num() == k,
_ => match self.bindings().get(var).unwrap() {
&VarData::Temp(_, o, _) if r.reg_num() == k => o == k,
_ => false
}
&VarData::Temp(_, o, _) if r.reg_num() == k => o == k,
_ => false,
},
}
}
}
impl<'a> Allocator<'a> for DebrayAllocator
{
impl<'a> Allocator<'a> for DebrayAllocator {
fn new() -> DebrayAllocator {
DebrayAllocator {
arity: 0,
arg_c: 1,
arity: 0,
arg_c: 1,
temp_lb: 1,
bindings: IndexMap::new(),
contents: IndexMap::new(),
in_use: BTreeSet::new()
in_use: BTreeSet::new(),
}
}
fn mark_anon_var<Target>(&mut self, lvl: Level, term_loc: GenContext, target: &mut Vec<Target>)
where Target: CompilationTarget<'a>
where
Target: CompilationTarget<'a>,
{
let r = RegType::Temp(self.alloc_reg_to_non_var());
@@ -230,15 +230,20 @@ impl<'a> Allocator<'a> for DebrayAllocator
}
self.arg_c += 1;
target.push(Target::argument_to_variable(r, k));
}
};
}
fn mark_non_var<Target>(&mut self, lvl: Level, term_loc: GenContext,
cell: &Cell<RegType>, target: &mut Vec<Target>)
where Target: CompilationTarget<'a>
fn mark_non_var<Target>(
&mut self,
lvl: Level,
term_loc: GenContext,
cell: &Cell<RegType>,
target: &mut Vec<Target>,
) where
Target: CompilationTarget<'a>,
{
let r = cell.get();
@@ -252,7 +257,7 @@ impl<'a> Allocator<'a> for DebrayAllocator
self.arg_c += 1;
RegType::Temp(k)
},
}
_ if r.reg_num() == 0 => RegType::Temp(self.alloc_reg_to_non_var()),
_ => {
self.in_use.insert(r.reg_num());
@@ -263,34 +268,47 @@ impl<'a> Allocator<'a> for DebrayAllocator
cell.set(r);
}
fn mark_var<Target>(&mut self, var: Rc<Var>, lvl: Level, cell: &'a Cell<VarReg>,
term_loc: GenContext, target: &mut Vec<Target>)
where Target: CompilationTarget<'a>
fn mark_var<Target>(
&mut self,
var: Rc<Var>,
lvl: Level,
cell: &'a Cell<VarReg>,
term_loc: GenContext,
target: &mut Vec<Target>,
) where
Target: CompilationTarget<'a>,
{
let (r, is_new_var) = match self.get(var.clone()) {
RegType::Temp(0) => {
// here, r is temporary *and* unassigned.
let o = self.alloc_reg_to_var(&var, lvl, term_loc, target);
cell.set(VarReg::Norm(RegType::Temp(o)));
(RegType::Temp(o), true)
},
}
RegType::Perm(0) => {
let pr = cell.get().norm();
self.record_register(var.clone(), pr);
(pr, true)
},
r => (r, false)
}
r => (r, false),
};
self.mark_reserved_var(var, lvl, cell, term_loc, target, r, is_new_var);
}
fn mark_reserved_var<Target>(&mut self, var: Rc<Var>, lvl: Level, cell: &'a Cell<VarReg>,
term_loc: GenContext, target: &mut Vec<Target>, r: RegType,
is_new_var: bool)
where Target: CompilationTarget<'a>
fn mark_reserved_var<Target>(
&mut self,
var: Rc<Var>,
lvl: Level,
cell: &'a Cell<VarReg>,
term_loc: GenContext,
target: &mut Vec<Target>,
r: RegType,
is_new_var: bool,
) where
Target: CompilationTarget<'a>,
{
match lvl {
Level::Root | Level::Shallow => {
@@ -311,8 +329,8 @@ impl<'a> Allocator<'a> for DebrayAllocator
target.push(Target::argument_to_value(r, k));
}
}
},
Level::Deep if is_new_var =>
}
Level::Deep if is_new_var => {
if let GenContext::Head = term_loc {
if self.occurs_shallowly_in_head(&var, r.reg_num()) {
target.push(Target::subterm_to_value(r));
@@ -321,9 +339,9 @@ impl<'a> Allocator<'a> for DebrayAllocator
}
} else {
target.push(Target::subterm_to_variable(r));
},
Level::Deep =>
target.push(Target::subterm_to_value(r))
}
}
Level::Deep => target.push(Target::subterm_to_value(r)),
};
if !r.is_perm() {
@@ -380,8 +398,8 @@ impl<'a> Allocator<'a> for DebrayAllocator
}
fn reset_arg(&mut self, arity: usize) {
self.arity = 0;
self.arg_c = 1;
self.arity = 0;
self.arg_c = 1;
self.temp_lb = arity + 1;
}
}