sanchayanmaity/gem5
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ruby: slicc: use default argument value

Browse source 
Before this patch, while one could declare / define a function with default
argument values, but the actual function call would require one to specify
all the arguments.  This patch changes the check for  function arguments.
Now a function call needs to specify arguments that are at least as much as
those with default values and at most the total number of arguments taken
as input by the function.
This commit is contained in:
Nilay Vaish 2015-08-14 19:28:43 -05:00
parent 7fc725fdb5
commit 9648c05db1
12 changed files with 69 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/mem/ruby/structures/AbstractReplacementPolicy.cc
View file

@ -66,7 +66,7 @@ AbstractReplacementPolicy::~AbstractReplacementPolicy()
}
Tick
AbstractReplacementPolicy::getLastAccess(int64 set, int64 way)
AbstractReplacementPolicy::getLastAccess(int64_t set, int64_t way)
{
return m_last_ref_ptr[set][way];
}

6
src/mem/ruby/structures/AbstractReplacementPolicy.hh
View file

@ -44,13 +44,13 @@ class AbstractReplacementPolicy : public SimObject
virtual ~AbstractReplacementPolicy();
/* touch a block. a.k.a. update timestamp */
virtual void touch(int64 set, int64 way, Tick time) = 0;
virtual void touch(int64_t set, int64_t way, Tick time) = 0;
/* returns the way to replace */
virtual int64 getVictim(int64 set) const = 0;
virtual int64_t getVictim(int64_t set) const = 0;
/* get the time of the last access */
Tick getLastAccess(int64 set, int64 way);
Tick getLastAccess(int64_t set, int64_t way);
virtual bool useOccupancy() const { return false; }

8
src/mem/ruby/structures/LRUPolicy.cc
View file

@ -50,7 +50,7 @@ LRUReplacementPolicyParams::create()
void
LRUPolicy::touch(int64 set, int64 index, Tick time)
LRUPolicy::touch(int64_t set, int64_t index, Tick time)
{
assert(index >= 0 && index < m_assoc);
assert(set >= 0 && set < m_num_sets);
@ -58,11 +58,11 @@ LRUPolicy::touch(int64 set, int64 index, Tick time)
m_last_ref_ptr[set][index] = time;
}
int64
LRUPolicy::getVictim(int64 set) const
int64_t
LRUPolicy::getVictim(int64_t set) const
{
Tick time, smallest_time;
int64 smallest_index;
int64_t smallest_index;
smallest_index = 0;
smallest_time = m_last_ref_ptr[set][0];

4
src/mem/ruby/structures/LRUPolicy.hh
View file

@ -41,8 +41,8 @@ class LRUPolicy : public AbstractReplacementPolicy
LRUPolicy(const Params * p);
~LRUPolicy();
void touch(int64 set, int64 way, Tick time);
int64 getVictim(int64 set) const;
void touch(int64_t set, int64_t way, Tick time);
int64_t getVictim(int64_t set) const;
};
#endif // __MEM_RUBY_STRUCTURES_LRUPOLICY_HH__

12
src/mem/ruby/structures/PseudoLRUPolicy.cc
View file

@ -38,7 +38,7 @@ PseudoLRUPolicy::PseudoLRUPolicy(const Params * p)
// associativity cannot exceed capacity of tree representation
assert(m_num_sets > 0 &&
m_assoc > 1 &&
m_assoc <= (int64) sizeof(uint64)*4);
m_assoc <= (int64_t) sizeof(uint64_t)*4);
m_trees = NULL;
m_num_levels = 0;
@ -55,7 +55,7 @@ PseudoLRUPolicy::PseudoLRUPolicy(const Params * p)
m_num_levels++;
}
assert(m_num_levels < sizeof(unsigned int)*4);
m_trees = new uint64[m_num_sets];
m_trees = new uint64_t[m_num_sets];
for (unsigned i = 0; i < m_num_sets; i++) {
m_trees[i] = 0;
}
@ -75,7 +75,7 @@ PseudoLRUPolicy::~PseudoLRUPolicy()
}
void
PseudoLRUPolicy::touch(int64 set, int64 index, Tick time)
PseudoLRUPolicy::touch(int64_t set, int64_t index, Tick time)
{
assert(index >= 0 && index < m_assoc);
assert(set >= 0 && set < m_num_sets);
@ -93,10 +93,10 @@ PseudoLRUPolicy::touch(int64 set, int64 index, Tick time)
m_last_ref_ptr[set][index] = time;
}
int64
PseudoLRUPolicy::getVictim(int64 set) const
int64_t
PseudoLRUPolicy::getVictim(int64_t set) const
{
int64 index = 0;
int64_t index = 0;
int tree_index = 0;
int node_val;

6
src/mem/ruby/structures/PseudoLRUPolicy.hh
View file

@ -53,13 +53,13 @@ class PseudoLRUPolicy : public AbstractReplacementPolicy
PseudoLRUPolicy(const Params * p);
~PseudoLRUPolicy();
void touch(int64 set, int64 way, Tick time);
int64 getVictim(int64 set) const;
void touch(int64_t set, int64_t way, Tick time);
int64_t getVictim(int64_t set) const;
private:
unsigned int m_effective_assoc; /** nearest (to ceiling) power of 2 */
unsigned int m_num_levels; /** number of levels in the tree */
uint64* m_trees; /** bit representation of the
uint64_t *m_trees; /** bit representation of the
* trees, one for each set */
};

2
src/mem/slicc/ast/EnumDeclAST.py
View file

@ -67,6 +67,6 @@ class EnumDeclAST(DeclAST):
pairs = { "external" : "yes" }
func = Func(self.symtab, func_id + "_" + t.c_ident,
func_id, self.location,
self.symtab.find("std::string", Type), [ t ], [], "",
self.symtab.find("std::string", Type), [ t ], [], [], "",
pairs)
self.symtab.newSymbol(func)

22
src/mem/slicc/ast/FormalParamAST.py
View file

@ -46,6 +46,9 @@ class FormalParamAST(AST):
def generate(self):
type = self.type_ast.type
param = "param_%s" % self.ident
proto = ""
body = ""
default = False
# Add to symbol table
v = Var(self.symtab, self.ident, self.location, type, param,
@ -56,6 +59,21 @@ class FormalParamAST(AST):
"interface" in type and (
type["interface"] == "AbstractCacheEntry" or
type["interface"] == "AbstractEntry")):
return type, "%s* %s" % (type.c_ident, param)
proto = "%s* %s" % (type.c_ident, param)
body = proto
elif self.default != None:
value = ""
if self.default == True:
value = "true"
elif self.default == False:
value = "false"
else:
return type, "const %s& %s" % (type.c_ident, param)
value = "%s" % self.default
proto = "const %s& %s = %s" % (type.c_ident, param, value)
body = "const %s& %s" % (type.c_ident, param)
default = True
else:
proto = "const %s& %s" % (type.c_ident, param)
body = proto
return type, proto, body, default

17
src/mem/slicc/ast/FuncDeclAST.py
View file

@ -45,7 +45,9 @@ class FuncDeclAST(DeclAST):
def generate(self, parent = None):
types = []
params = []
proto_params = []
body_params = []
default_count = 0
void_type = self.symtab.find("void", Type)
# Generate definition code
@ -58,13 +60,17 @@ class FuncDeclAST(DeclAST):
for formal in self.formals:
# Lookup parameter types
try:
type, ident = formal.generate()
type, proto, body, default = formal.generate()
types.append(type)
params.append(ident)
proto_params.append(proto)
body_params.append(body)
if default:
default_count += 1
except AttributeError:
types.append(formal.type)
params.append(None)
proto_params.append(None)
body_params.append(None)
body = self.slicc.codeFormatter()
if self.statements is None:
@ -87,7 +93,8 @@ class FuncDeclAST(DeclAST):
machine = self.state_machine
func = Func(self.symtab, func_name_args, self.ident, self.location,
return_type, types, params, str(body), self.pairs)
return_type, types, proto_params,
body_params, str(body), self.pairs, default_count)
if parent is not None:
if not parent.addFunc(func):

4
src/mem/slicc/ast/InPortDeclAST.py
View file

@ -89,13 +89,13 @@ class InPortDeclAST(DeclAST):
for param in param_types:
trigger_func_name += "_" + param.ident
func = Func(self.symtab, trigger_func_name, "trigger", self.location,
void_type, param_types, [], "", pairs)
void_type, param_types, [], [], "", pairs)
symtab.newSymbol(func)
# Add the stallPort method - this hacks reschedules the controller
# for stalled messages that don't trigger events
func = Func(self.symtab, "stallPort", "stallPort", self.location,
void_type, [], [], "", pairs)
void_type, [], [], [], "", pairs)
symtab.newSymbol(func)
param_types = []

4
src/mem/slicc/ast/StateDeclAST.py
View file

@ -66,7 +66,7 @@ class StateDeclAST(DeclAST):
pairs = { "external" : "yes" }
func = Func(self.symtab, func_id + "_" +
t.ident, func_id, self.location,
self.symtab.find("std::string", Type), [ t ], [], "",
self.symtab.find("std::string", Type), [ t ], [], [], "",
pairs)
self.symtab.newSymbol(func)
@ -76,6 +76,6 @@ class StateDeclAST(DeclAST):
pairs = { "external" : "yes" }
func = Func(self.symtab, func_id + "_" +
t.ident, func_id, self.location,
self.symtab.find("AccessPermission", Type), [ t ], [], "",
self.symtab.find("AccessPermission", Type), [ t ], [], [], "",
pairs)
self.symtab.newSymbol(func)

20
src/mem/slicc/symbols/Func.py
View file

@ -30,16 +30,19 @@ from slicc.symbols.Type import Type
class Func(Symbol):
def __init__(self, table, ident, name, location, return_type, param_types,
param_strings, body, pairs):
proto_param_strings, body_param_strings, body,
pairs, default_count = 0):
super(Func, self).__init__(table, ident, location, pairs)
self.return_type = return_type
self.param_types = param_types
self.param_strings = param_strings
self.proto_param_strings = proto_param_strings
self.body_param_strings = body_param_strings
self.body = body
self.isInternalMachineFunc = False
self.c_ident = ident
self.c_name = name
self.class_name = ""
self.default_count = default_count
def __repr__(self):
return ""
@ -57,16 +60,17 @@ class Func(Symbol):
return_type += "*"
return "%s %s(%s);" % (return_type, self.c_name,
", ".join(self.param_strings))
", ".join(self.proto_param_strings))
def writeCodeFiles(self, path, includes):
return
def checkArguments(self, args):
if len(args) != len(self.param_types):
if len(args) + self.default_count < len(self.param_types) or \
len(args) > len(self.param_types):
self.error("Wrong number of arguments passed to function: '%s'" + \
" Expected %d, got %d", self.c_ident,
len(self.param_types), len(args))
" Expected at least: %d, got: %d", self.c_ident,
len(self.param_types) - self.default_count, len(args))
cvec = []
type_vec = []
@ -91,14 +95,14 @@ class Func(Symbol):
code = self.symtab.codeFormatter()
# Generate function header
void_type = self.symtab.find("void", Type)
return_type = self.return_type.c_ident
void_type = self.symtab.find("void", Type)
if "return_by_ref" in self and self.return_type != void_type:
return_type += "&"
if "return_by_pointer" in self and self.return_type != void_type:
return_type += "*"
params = ', '.join(self.param_strings)
params = ', '.join(self.body_param_strings)
code('''
$return_type