From 2f30950143cc70bc42a3c8a4111d7cf8198ec881 Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Mon, 11 May 2009 10:38:43 -0700 Subject: ruby: Import ruby and slicc from GEMS We eventually plan to replace the m5 cache hierarchy with the GEMS hierarchy, but for now we will make both live alongside eachother. --- src/mem/gems_common/Allocator.hh | 83 +++++ src/mem/gems_common/Map.hh | 186 ++++++++++ src/mem/gems_common/PrioHeap.hh | 249 +++++++++++++ src/mem/gems_common/RefCnt.hh | 162 +++++++++ src/mem/gems_common/RefCnt_tester.cc | 78 ++++ src/mem/gems_common/RefCountable.hh | 59 +++ src/mem/gems_common/Vector.hh | 334 +++++++++++++++++ src/mem/gems_common/calc_host.sh | 38 ++ src/mem/gems_common/ioutil/attrlex.ll | 229 ++++++++++++ src/mem/gems_common/ioutil/attrparse.yy | 232 ++++++++++++ src/mem/gems_common/ioutil/confio.cc | 456 +++++++++++++++++++++++ src/mem/gems_common/ioutil/confio.hh | 192 ++++++++++ src/mem/gems_common/ioutil/embedtext.py | 54 +++ src/mem/gems_common/ioutil/initvar.cc | 626 ++++++++++++++++++++++++++++++++ src/mem/gems_common/ioutil/initvar.hh | 181 +++++++++ src/mem/gems_common/ioutil/vardecl.hh | 75 ++++ src/mem/gems_common/std-includes.hh | 51 +++ src/mem/gems_common/util.cc | 109 ++++++ src/mem/gems_common/util.hh | 68 ++++ 19 files changed, 3462 insertions(+) create mode 100644 src/mem/gems_common/Allocator.hh create mode 100644 src/mem/gems_common/Map.hh create mode 100644 src/mem/gems_common/PrioHeap.hh create mode 100644 src/mem/gems_common/RefCnt.hh create mode 100644 src/mem/gems_common/RefCnt_tester.cc create mode 100644 src/mem/gems_common/RefCountable.hh create mode 100644 src/mem/gems_common/Vector.hh create mode 100755 src/mem/gems_common/calc_host.sh create mode 100644 src/mem/gems_common/ioutil/attrlex.ll create mode 100644 src/mem/gems_common/ioutil/attrparse.yy create mode 100644 src/mem/gems_common/ioutil/confio.cc create mode 100644 src/mem/gems_common/ioutil/confio.hh create mode 100644 src/mem/gems_common/ioutil/embedtext.py create mode 100644 src/mem/gems_common/ioutil/initvar.cc create mode 100644 src/mem/gems_common/ioutil/initvar.hh create mode 100644 src/mem/gems_common/ioutil/vardecl.hh create mode 100644 src/mem/gems_common/std-includes.hh create mode 100644 src/mem/gems_common/util.cc create mode 100644 src/mem/gems_common/util.hh (limited to 'src/mem/gems_common') diff --git a/src/mem/gems_common/Allocator.hh b/src/mem/gems_common/Allocator.hh new file mode 100644 index 000000000..109696601 --- /dev/null +++ b/src/mem/gems_common/Allocator.hh @@ -0,0 +1,83 @@ +/* + * Copyright (c) 1999 by Mark Hill and David Wood for the Wisconsin + * Multifacet Project. ALL RIGHTS RESERVED. + * + * ##HEADER## + * + * This software is furnished under a license and may be used and + * copied only in accordance with the terms of such license and the + * inclusion of the above copyright notice. This software or any + * other copies thereof or any derivative works may not be provided or + * otherwise made available to any other persons. Title to and + * ownership of the software is retained by Mark Hill and David Wood. + * Any use of this software must include the above copyright notice. + * + * THIS SOFTWARE IS PROVIDED "AS IS". THE LICENSOR MAKES NO + * WARRANTIES ABOUT ITS CORRECTNESS OR PERFORMANCE. + * */ + +/* + * $Id$ + */ + +#ifndef ALLOCATOR_H +#define ALLOCATOR_H + +#include "Vector.hh" + +template +class Allocator { +public: + // Constructors + Allocator() { m_counter = 0; } + + // Destructor + ~Allocator() { for(int i=0; i m_pool_vec; + int m_counter; +}; + +template +inline +TYPE* Allocator::allocate(const TYPE& obj) +{ + m_counter++; + DEBUG_EXPR(ALLOCATOR_COMP, LowPrio, m_counter); + TYPE* new_obj_ptr; + + // See if we need to allocate any new objects + if (m_pool_vec.size() == 0) { + // Allocate a new item + m_pool_vec.insertAtBottom(new TYPE); + } + + // Pop the pointer from the stack/pool + int size = m_pool_vec.size(); + new_obj_ptr = m_pool_vec[size-1]; + m_pool_vec.setSize(size-1); + + // Copy the object + *new_obj_ptr = obj; + return new_obj_ptr; +} + +template +inline +void Allocator::deallocate(TYPE* obj) +{ + m_pool_vec.insertAtBottom(obj); +} + +#endif //ALLOCATOR_H diff --git a/src/mem/gems_common/Map.hh b/src/mem/gems_common/Map.hh new file mode 100644 index 000000000..1ecd13d64 --- /dev/null +++ b/src/mem/gems_common/Map.hh @@ -0,0 +1,186 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * $Id$ + * + */ + +#ifndef MAP_H +#define MAP_H + +#include "Vector.hh" + +namespace __gnu_cxx { + template <> struct hash + { + size_t operator()(const string& s) const { return hash()(s.c_str()); } + }; +} + +typedef unsigned long long uint64; +//hack for uint64 hashes... +namespace __gnu_cxx { + template <> struct hash + { + size_t operator()(const uint64 & s) const { return (size_t) s; } + }; +} + +template +class Map +{ +public: + Map() { /* empty */ } + ~Map() { /* empty */ } + + void add(const KEY_TYPE& key, const VALUE_TYPE& value); + bool exist(const KEY_TYPE& key) const; + int size() const { return m_map.size(); } + void erase(const KEY_TYPE& key) { assert(exist(key)); m_map.erase(key); } + Vector keys() const; + Vector values() const; + void deleteKeys(); + void deleteValues(); + VALUE_TYPE& lookup(const KEY_TYPE& key) const; + void clear() { m_map.clear(); } + void print(ostream& out) const; + + // Synonyms + void remove(const KEY_TYPE& key) { erase(key); } + void deallocate(const KEY_TYPE& key) { erase(key); } + void allocate(const KEY_TYPE& key) { add(key, VALUE_TYPE()); } + void insert(const KEY_TYPE& key, const VALUE_TYPE& value) { add(key, value); } + + // Use default copy constructor and assignment operator +private: + // Data members + + // m_map is declared mutable because some methods from the STL "map" + // class that should be const are not. Thus we define this as + // mutable so we can still have conceptually const accessors. + mutable __gnu_cxx::hash_map m_map; +}; + +template +ostream& operator<<(ostream& out, const Map& map); + +// ********************* + +template +void Map::add(const KEY_TYPE& key, const VALUE_TYPE& value) +{ + // Update or add a new key/value pair + m_map[key] = value; +} + +template +bool Map::exist(const KEY_TYPE& key) const +{ + return (m_map.count(key) != 0); +} + +template +VALUE_TYPE& Map::lookup(const KEY_TYPE& key) const +{ + assert(exist(key)); + return m_map[key]; +} + +template +Vector Map::keys() const +{ + Vector keys; + typename hash_map::const_iterator iter; + for (iter = m_map.begin(); iter != m_map.end(); iter++) { + keys.insertAtBottom((*iter).first); + } + return keys; +} + +template +Vector Map::values() const +{ + Vector values; + typename hash_map::const_iterator iter; + pair p; + + for (iter = m_map.begin(); iter != m_map.end(); iter++) { + p = *iter; + values.insertAtBottom(p.second); + } + return values; +} + +template +void Map::deleteKeys() +{ + typename hash_map::const_iterator iter; + pair p; + + for (iter = m_map.begin(); iter != m_map.end(); iter++) { + p = *iter; + delete p.first; + } +} + +template +void Map::deleteValues() +{ + typename hash_map::const_iterator iter; + pair p; + + for (iter = m_map.begin(); iter != m_map.end(); iter++) { + p = *iter; + delete p.second; + } +} + +template +void Map::print(ostream& out) const +{ + typename hash_map::const_iterator iter; + pair p; + + out << "["; + for (iter = m_map.begin(); iter != m_map.end(); iter++) { + // unparse each basic block + p = *iter; + out << " " << p.first << "=" << p.second; + } + out << " ]"; +} + +template +ostream& operator<<(ostream& out, const Map& map) +{ + map.print(out); + return out; +} + +#endif //MAP_H diff --git a/src/mem/gems_common/PrioHeap.hh b/src/mem/gems_common/PrioHeap.hh new file mode 100644 index 000000000..d549f0944 --- /dev/null +++ b/src/mem/gems_common/PrioHeap.hh @@ -0,0 +1,249 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef PRIOHEAP_H +#define PRIOHEAP_H + +#include "Vector.hh" + +typedef unsigned int HeapIndex; + +template +class PrioHeap { +public: + // Constructors + PrioHeap() { init(); } + + // Destructor + //~PrioHeap(); + + // Public Methods + void init() { m_current_size = 0; } + int size() const { return m_current_size; } + void insert(const TYPE& key); + const TYPE& peekMin() const; + const TYPE& peekElement(int index) const; + TYPE extractMin(); + void print(ostream& out) const; +private: + // Private Methods + bool verifyHeap() const; + bool verifyHeap(HeapIndex index) const; + void heapify(); + + // Private copy constructor and assignment operator + PrioHeap(const PrioHeap& obj); + PrioHeap& operator=(const PrioHeap& obj); + + // Data Members (m_ prefix) + Vector m_heap; + HeapIndex m_current_size; +}; + +// Output operator declaration +template +ostream& operator<<(ostream& out, const PrioHeap& obj); + +// ******************* Helper Functions ******************* +inline +HeapIndex get_parent(HeapIndex i) +{ + // return (i/2); + return (i>>1); +} + +inline +HeapIndex get_right(HeapIndex i) +{ + // return (2*i) + 1; + return (i<<1) | 1; +} + +inline +HeapIndex get_left(HeapIndex i) +{ + // return (2*i); + return (i<<1); +} + +template +void prio_heap_swap(TYPE& n1, TYPE& n2) +{ + TYPE temp = n1; + n1 = n2; + n2 = temp; +} + +// ******************* Definitions ******************* + +template +void PrioHeap::insert(const TYPE& key) +{ + int i; + // grow the vector size + m_current_size++; + m_heap.setSize(m_current_size+1); + + if(m_current_size == 1){ // HACK: need to initialize index 0 to avoid purify UMCs + m_heap[0] = key; + } + + i = m_current_size; + while ((i > 1) && (node_less_then_eq(key, m_heap[get_parent(i)]))) { + m_heap[i] = m_heap[get_parent(i)]; + i = get_parent(i); + } + m_heap[i] = key; + // assert(verifyHeap()); +} + +template +const TYPE& PrioHeap::peekMin() const +{ + assert(size() > 0); + return m_heap[1]; // 1, not 0, is the first element +} + +template +const TYPE& PrioHeap::peekElement(int index) const +{ + assert(size() > 0); + return m_heap[index]; +} + +template +TYPE PrioHeap::extractMin() +{ + // TYPE temp; + assert(size() > 0); + TYPE temp = m_heap[1]; // 1, not 0, is the first element + m_heap[1] = m_heap[m_current_size]; + m_current_size--; + heapify(); + return temp; +} + +template +bool PrioHeap::verifyHeap() const +{ + return verifyHeap(1); +} + +template +bool PrioHeap::verifyHeap(HeapIndex index) const +{ + // Recursively verify that each node is <= its parent + if(index > m_current_size) { + return true; + } else if (index == 1) { + return + verifyHeap(get_right(index)) && + verifyHeap(get_left(index)); + } else if (node_less_then_eq(m_heap[get_parent(index)], m_heap[index])) { + return + verifyHeap(get_right(index)) && + verifyHeap(get_left(index)); + } else { + // Heap property violation + return false; + } +} + +template +void PrioHeap::heapify() +{ + HeapIndex current_node = 1; + HeapIndex left, right, smallest; + // HeapIndex size = m_current_size; + + while(true) { + left = get_left(current_node); + right = get_right(current_node); + + // Find the smallest of the current node and children + if (left <= m_current_size && node_less_then_eq(m_heap[left], m_heap[current_node])) { + smallest = left; + } else { + smallest = current_node; + } + + if (right <= m_current_size && node_less_then_eq(m_heap[right], m_heap[smallest])) { + smallest = right; + } + + // Check to see if we are done + if (smallest == current_node) { + // We are done + break; + } else { + // Not done, heapify on the smallest child + prio_heap_swap(m_heap[current_node], m_heap[smallest]); + current_node = smallest; + } + } + // assert(verifyHeap()); +} + +template +void PrioHeap::print(ostream& out) const +{ + Vector copyHeap(m_heap); + + // sort copyHeap (inefficient, but will not be done often) + + for(HeapIndex i=0;i +ostream& operator<<(ostream& out, const PrioHeap& obj) +{ + obj.print(out); + out << flush; + return out; +} + +#endif //PRIOHEAP_H diff --git a/src/mem/gems_common/RefCnt.hh b/src/mem/gems_common/RefCnt.hh new file mode 100644 index 000000000..fc1ddbae9 --- /dev/null +++ b/src/mem/gems_common/RefCnt.hh @@ -0,0 +1,162 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef REFCNT_H +#define REFCNT_H + +template +class RefCnt { +public: + // Constructors + RefCnt(); + RefCnt(const TYPE& data); + + // Destructor + ~RefCnt(); + + // Public Methods + const TYPE* ref() const { return m_data_ptr; } + TYPE* ref() { return m_data_ptr; } + TYPE* mod_ref() const { return m_data_ptr; } + void freeRef(); + void print(ostream& out) const; + + // Public copy constructor and assignment operator + RefCnt(const RefCnt& obj); + RefCnt& operator=(const RefCnt& obj); + +private: + // Private Methods + + // Data Members (m_ prefix) + TYPE* m_data_ptr; + // int* m_count_ptr; // Not used yet +}; + +// Output operator declaration +template +inline +ostream& operator<<(ostream& out, const RefCnt& obj); + +// ******************* Definitions ******************* + +// Constructors +template +inline +RefCnt::RefCnt() +{ + m_data_ptr = NULL; +} + +template +inline +RefCnt::RefCnt(const TYPE& data) +{ + m_data_ptr = data.clone(); + m_data_ptr->setRefCnt(1); +} + +template +inline +RefCnt::~RefCnt() +{ + freeRef(); +} + +template +inline +void RefCnt::freeRef() +{ + if (m_data_ptr != NULL) { + m_data_ptr->decRefCnt(); + if (m_data_ptr->getRefCnt() == 0) { + m_data_ptr->destroy(); + } + m_data_ptr = NULL; + } +} + +template +inline +void RefCnt::print(ostream& out) const +{ + if (m_data_ptr == NULL) { + out << "[RefCnt: Null]"; + } else { + out << "[RefCnt: "; + m_data_ptr->print(out); + out << "]"; + } +} + +// Copy constructor +template +inline +RefCnt::RefCnt(const RefCnt& obj) +{ + // m_data_ptr = obj.m_data_ptr->clone(); + m_data_ptr = obj.m_data_ptr; + + // Increment the reference count + if (m_data_ptr != NULL) { + m_data_ptr->incRefCnt(); + } +} + +// Assignment operator +template +inline +RefCnt& RefCnt::operator=(const RefCnt& obj) +{ + if (this == &obj) { + // If this is the case, do nothing + // assert(false); + } else { + freeRef(); + m_data_ptr = obj.m_data_ptr; + if (m_data_ptr != NULL) { + m_data_ptr->incRefCnt(); + } + } + return *this; +} + + +// Output operator definition +template +inline +ostream& operator<<(ostream& out, const RefCnt& obj) +{ + obj.print(out); + out << flush; + return out; +} + + + +#endif //REFCNT_H diff --git a/src/mem/gems_common/RefCnt_tester.cc b/src/mem/gems_common/RefCnt_tester.cc new file mode 100644 index 000000000..574f8fe3c --- /dev/null +++ b/src/mem/gems_common/RefCnt_tester.cc @@ -0,0 +1,78 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Code used to test the RefCnt class + */ + +#include "RefCnt.hh" +#include "RefCountable.hh" + +class Foo : public RefCountable { +public: + int m_data; + Foo* clone() const; +private: +}; + +Foo* Foo::clone() const +{ + Foo* temp_ptr; + temp_ptr = new Foo; + *temp_ptr = *this; + cout << "Cloned!" << endl; + return temp_ptr; +} + +void bar(RefCnt f) +{ + cout << f.ref()->m_data << endl; +} + +Foo f2; + +int main() +{ + Foo f; + f.m_data = 2; + + { + RefCnt a(f); + + f.m_data = 3; + cout << a.ref()->m_data << endl; + cout << f.m_data << endl; + f2 = f; + } + + bar(f2); + + return 0; +} + + diff --git a/src/mem/gems_common/RefCountable.hh b/src/mem/gems_common/RefCountable.hh new file mode 100644 index 000000000..88aba07e6 --- /dev/null +++ b/src/mem/gems_common/RefCountable.hh @@ -0,0 +1,59 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Virtual base class for things that can be reference counted + */ + +#ifndef REFCOUNTABLE_H +#define REFCOUNTABLE_H + +#include "RefCnt.hh" + +class RefCountable { +public: + // Public Methods + + RefCountable() { m_refcnt = 0; } + + // These are used by the RefCnt class to hold the reference count + // for the object. These really should be private and accessed by a + // friend class, but I can't figure out how to make a template class + // a friend. + void incRefCnt() { m_refcnt++; } + void decRefCnt() { m_refcnt--; } + int getRefCnt() const { return m_refcnt; } + void setRefCnt(int cnt) { m_refcnt = cnt; } +private: + // Private Methods + + // Data Members (m_ prefix) + int m_refcnt; +}; + +#endif //REFCOUNTABLE_H diff --git a/src/mem/gems_common/Vector.hh b/src/mem/gems_common/Vector.hh new file mode 100644 index 000000000..744dc698c --- /dev/null +++ b/src/mem/gems_common/Vector.hh @@ -0,0 +1,334 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * Description: The Vector class is a generic container which acts + * much like an array. The Vector class handles dynamic sizing and + * resizing as well as performing bounds checking on each access. An + * "insertAtBottom" operation is supported to allow adding elements to + * the Vector much like you would add new elements to a linked list or + * queue. + */ + +#ifndef VECTOR_H +#define VECTOR_H + +#include "std-includes.hh" + +template +class Vector +{ +public: + Vector(); + explicit Vector(int initial_size); // Construct with an initial max size + ~Vector(); + const TYPE& ref(int index) const; // Get an element of the vector + TYPE& ref(int index); // Get an element of the vector + void clear(); // remove all elements of the vector + void sortVector(); // sort all elements using < operator + int size() const { return m_size; } + void setSize(int new_size); // Increase size, reallocates memory as needed + void expand(int num) { setSize(m_size+num); } // Increase size by num + void increaseSize(int new_size, const TYPE& reset); // and adds num of slots at the bottom set to reset value + void insertAtTop(const TYPE& element); // Increase size by one and set last element + // FIXME - WARNING: insertAtTop is currently O(n) and needs to be fixed + void insertAtBottom(const TYPE& element); // Increase size by one and set last element + TYPE sum() const; // Uses the += operator to sum all the elements of the vector + void deletePointers(); // Walks the Vector calling delete on all + // elements and sets them to NULL, can only + // be used when the TYPE is a pointer type. + void removeFromTop(int num); // removes elements from top + void print(ostream& out) const; + + + // Array Reference operator overloading + const TYPE& operator[](int index) const { return ref(index); } + TYPE& operator[](int index) { return ref(index); } + + // Public copy constructor and assignment operator + Vector(const Vector& vec); + Vector& operator=(const Vector& vec); +private: + + void grow(int new_max_size); // Expands vector to new_max_size + + // Data members + TYPE* m_vec; // Array to hold the elements + int m_size; // Number of elements in use + int m_max_size; // Size of allocated array +}; + +template +ostream& operator<<(ostream& out, const Vector& vec); + +// ********************* + +template +Vector::Vector() +{ + m_size = 0; + m_max_size = 0; + m_vec = NULL; +} + +template +Vector::Vector(int initial_size) +{ + m_size = 0; + m_max_size = initial_size; + m_vec = NULL; + grow(initial_size); +} + +template +Vector::~Vector() +{ + delete [] m_vec; +} + +template +const TYPE& Vector::ref(int index) const +{ +#ifndef NO_VECTOR_BOUNDS_CHECKS + assert(m_size != 0); + assert(index < m_size); + assert(index >= 0); +#endif + return m_vec[index]; +} + +template +TYPE& Vector::ref(int index) +{ +#ifndef NO_VECTOR_BOUNDS_CHECKS + assert(m_size != 0); + assert(index < m_size); + assert(index >= 0); +#endif + return m_vec[index]; +} + + +template +void Vector::setSize(int new_size) +{ + // FIXME - this should also decrease or shrink the size of the array at some point. + if (new_size > m_max_size) { + grow(max((m_max_size+1)*2, new_size)); + } + m_size = new_size; +#ifndef NO_VECTOR_BOUNDS_CHECKS + assert(m_size <= m_max_size); + assert(m_size >= 0); +#endif +} + +template +inline +void Vector::increaseSize(int new_size, const TYPE& reset) +{ + assert(new_size >= m_size); + if (new_size >= m_max_size) { + grow(max((m_max_size+1)*2, new_size)); + } + int old_size = m_size; + m_size = new_size; + for (int j = old_size; j < m_size; j++) { + ref(j) = reset; + } + +#ifndef NO_VECTOR_BOUNDS_CHECKS + assert(m_size <= m_max_size); + assert(m_size >= 0); +#endif +} + +template +inline +void Vector::clear() +{ + m_size = 0; + m_max_size = 0; + delete [] m_vec; + m_vec = NULL; +} + +template +inline +void Vector::sortVector() +{ + sort(&m_vec[0], &m_vec[m_size]); +} + +template +inline +void Vector::insertAtTop(const TYPE& element) +{ + setSize(m_size+1); + for (int i = m_size-1; i >= 1; i--) { + ref(i) = ref(i-1); + } + ref(0) = element; +} + +template +inline +void Vector::removeFromTop(int num) +{ + if (num > m_size) { + num = m_size; + } + for (int i = 0; i < m_size - num; i++) { + m_vec[i] = m_vec[i+num]; + } + m_size = m_size - num; + +} + +template +void Vector::insertAtBottom(const TYPE& element) +{ + setSize(m_size+1); + ref(m_size-1) = element; +} + +template +TYPE Vector::sum() const +{ + assert(m_size > 0); + TYPE sum = ref(0); + for(int i=1; i +void Vector::deletePointers() +{ + assert(m_size >= 0); + for(int i=0; i +void Vector::print(ostream& out) const +{ + out << "[ "; + for(int i=0; i +Vector::Vector(const Vector& vec) +{ + // Setup the new memory + m_size = vec.m_size; + m_max_size = vec.m_max_size; + if (m_max_size != 0) { + m_vec = new TYPE[m_max_size]; + assert(m_vec != NULL); + } else { + m_vec = NULL; + } + + // Copy the elements of the array + for(int i=0; i +Vector& Vector::operator=(const Vector& vec) +{ + if (this == &vec) { + // assert(0); + } else { + // Free the old memory + delete [] m_vec; + + // Setup the new memory + m_size = vec.m_size; + m_max_size = vec.m_max_size; + + if (m_max_size != 0) { + m_vec = new TYPE[m_max_size]; + assert(m_vec != NULL); + } else { + m_vec = NULL; + } + + // Copy the elements of the array + for(int i=0; i +void Vector::grow(int new_max_size) +{ + TYPE* temp_vec; + m_max_size = new_max_size; + if (new_max_size != 0) { + temp_vec = new TYPE[new_max_size]; + assert(temp_vec != NULL); + } else { + temp_vec = NULL; + } + + // Copy the elements of the array + for(int i=0; i +ostream& operator<<(ostream& out, const Vector& vec) +{ + vec.print(out); + return out; +} + +#endif //VECTOR_H diff --git a/src/mem/gems_common/calc_host.sh b/src/mem/gems_common/calc_host.sh new file mode 100755 index 000000000..f7a6116c1 --- /dev/null +++ b/src/mem/gems_common/calc_host.sh @@ -0,0 +1,38 @@ +#!/bin/csh -f + +set OS=`uname -s` +set HOST_ARCH=`uname -m` + +switch ($OS) + case Linux: + set OS_PART=linux + breaksw + case SunOS: + set OS_PART=sol8-64 + breaksw + case OSF1: + set OS_PART=tru64-gcc + breaksw + default: + set OS_PART=`echo $OS | sed 's/ /-/g'` +endsw + +switch ($HOST_ARCH) + case i586: + set ARCH=x86 + breaksw + case i686: + set ARCH=x86 + breaksw + case x86_64: + set ARCH=amd64 + breaksw + case sun4u: + set ARCH=v9 + breaksw + default: + set ARCH=`echo $HOST_ARCH | sed 's/ /-/g'` +endsw + +echo $ARCH-$OS_PART + diff --git a/src/mem/gems_common/ioutil/attrlex.ll b/src/mem/gems_common/ioutil/attrlex.ll new file mode 100644 index 000000000..293350b23 --- /dev/null +++ b/src/mem/gems_common/ioutil/attrlex.ll @@ -0,0 +1,229 @@ +/* + Copyright (C) 1999-2005 by Mark D. Hill and David A. Wood for the + Wisconsin Multifacet Project. Contact: gems@cs.wisc.edu + http://www.cs.wisc.edu/gems/ + + -------------------------------------------------------------------- + + This file a component of the Multifacet GEMS (General + Execution-driven Multiprocessor Simulator) software toolset + originally developed at the University of Wisconsin-Madison. + + Ruby was originally developed primarily by Milo Martin and Daniel + Sorin with contributions from Ross Dickson, Carl Mauer, and Manoj + Plakal. + + SLICC was originally developed by Milo Martin with substantial + contributions from Daniel Sorin. + + Opal was originally developed by Carl Mauer based upon code by + Craig Zilles. + + Substantial further development of Multifacet GEMS at the + University of Wisconsin was performed by Alaa Alameldeen, Brad + Beckmann, Ross Dickson, Pacia Harper, Milo Martin, Michael Marty, + Carl Mauer, Kevin Moore, Manoj Plakal, Daniel Sorin, Min Xu, and + Luke Yen. + + -------------------------------------------------------------------- + + If your use of this software contributes to a published paper, we + request that you (1) cite our summary paper that appears on our + website (http://www.cs.wisc.edu/gems/) and (2) e-mail a citation + for your published paper to gems@cs.wisc.edu. + + If you redistribute derivatives of this software, we request that + you notify us and either (1) ask people to register with us at our + website (http://www.cs.wisc.edu/gems/) or (2) collect registration + information and periodically send it to us. + + -------------------------------------------------------------------- + + Multifacet GEMS is free software; you can redistribute it and/or + modify it under the terms of version 2 of the GNU General Public + License as published by the Free Software Foundation. + + Multifacet GEMS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with the Multifacet GEMS; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307, USA + + The GNU General Public License is contained in the file LICENSE. + +### END HEADER ### +*/ + + +%option noyywrap + +ALPHADIGIT [^\:\,\(\)\n\t\(\) \0\#] +HEXDIGIT [0-9a-fA-Fx] +NEWLINE [\n] +WHITESPACE [ \t] + +%{ + +#ifdef IS_RUBY +#include "Global.hh" +#endif + +using namespace std; +#include +#include +#include + +// Maurice +// extern "C" { +// #include "simics/api.h" +// }; + +#include "FakeSimicsDataTypes.hh" + +// CM: simics 1.6.5 API redefines fwrite, much to my chagrin +#undef fwrite +#undef printf +#include "attrparse.h" + +#define MAX_INCLUDE_DEPTH 10 + +/** global result of parsing file */ +extern attr_value_t g_attr_map; + +extern int atparse(void); + +static int linenum=1; /* the current line number */ +static int colnum=1; /* the current column number */ +static YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH]; +static int include_stack_ptr = 0; +static char g_relative_include_path[256]; + + +// forward declaration of aterror +void aterror(const char *msg); +%} + +%x SLASHCOMMENT INCLUDE + +%% + +%{ /* PATTERNS FOR STRING TOKENS */ +%} + +"//".*[\n] { linenum++; colnum=1; } /* C++ style comments */ + +\#include { colnum+=yyleng; BEGIN(INCLUDE); } +{WHITESPACE}* { colnum+=yyleng; } +[^ \t\n]+ { + // should really be FILEIO_MAX_FILENAME or MAX_NAME + char str[256]; + if ( include_stack_ptr >= MAX_INCLUDE_DEPTH ) + { + ERROR_OUT( "Includes nested too deeply" ); + exit( 1 ); + } + include_stack[include_stack_ptr++] = YY_CURRENT_BUFFER; + + yyin = fopen( yytext, "r" ); + if ( ! yyin ) { + sprintf( str, "%s%s", g_relative_include_path, yytext ); + yyin = fopen( str, "r" ); + } + if ( ! yyin ) { + sprintf( str, "%s%s%s", g_relative_include_path, "config/", yytext ); + yyin = fopen( str, "r" ); + } + if ( ! yyin ) { + ERROR_OUT("unable to open included file: %s or %s\n", yytext, str); + aterror("file open error.\n"); + } + yy_switch_to_buffer(yy_create_buffer( yyin, YY_BUF_SIZE )); + BEGIN(INITIAL); + } +<> { + if ( --include_stack_ptr < 0 ) { + yyterminate(); + } else { + yy_delete_buffer( YY_CURRENT_BUFFER ); + fclose(yyin); + yy_switch_to_buffer(include_stack[include_stack_ptr] ); + } + } + +\( { colnum+=yyleng; return (LPAREN); } +\) { colnum+=yyleng; return (RPAREN); } +\: { colnum+=yyleng; return (':'); } +\, { colnum+=yyleng; return (','); } +{HEXDIGIT}+ { + colnum+=yyleng; + attr_value_t *val = (attr_value_t *) + malloc( sizeof(attr_value_t) ); + memset( val, 0, sizeof(attr_value_t) ); + atlval.attrval = val; + val->kind = Sim_Val_Integer; + val->u.integer = strtoull( yytext, NULL, 0 ); + return (INTEGER); } +{ALPHADIGIT}+ { + colnum+=yyleng; + attr_value_t *val = (attr_value_t *) + malloc( sizeof(attr_value_t) ); + memset( val, 0, sizeof(attr_value_t) ); + atlval.attrval = val; + val->kind = Sim_Val_String; + val->u.string = strdup(yytext); + return (STRING); } + +%{ /* OTHER PATTERNS */ +%} + +{WHITESPACE}+ {colnum += yyleng;} +{NEWLINE} {linenum++; colnum = 1;} + +%% + +extern "C" void parseInitialize( void ) +{ + // since no global variables are set in simics, we must do it manually + // this is also necessary now that the parser can be used more than once. + // (it is used to parse the defaults, and can be used after that) + linenum = 1; + colnum = 1; + include_stack_ptr = 0; +} + +extern "C" int parseAttrFile( FILE *inputFile, const char *relative_include_path, attr_value_t *myTable ) +{ + parseInitialize(); + strncpy( g_relative_include_path, relative_include_path, 255 ); + + int result; + yyin = inputFile; + YY_BUFFER_STATE scan_state = yy_create_buffer( yyin, YY_BUF_SIZE ); + yy_switch_to_buffer( scan_state ); + result = atparse(); + *myTable = g_attr_map; + yy_delete_buffer( scan_state ); + return (result); +} + +extern "C" int parseAttrString( const char *str, attr_value_t *myTable ) +{ + parseInitialize(); + + int result; + YY_BUFFER_STATE scan_state = yy_scan_string( str ); + result = atparse(); + *myTable = g_attr_map; + yy_delete_buffer( scan_state ); + return (result); +} + +extern void aterror(const char *msg) +{ + ERROR_OUT("%d:%d: ERROR while parsing config file%s\n", linenum, colnum, msg ); +} + diff --git a/src/mem/gems_common/ioutil/attrparse.yy b/src/mem/gems_common/ioutil/attrparse.yy new file mode 100644 index 000000000..8a0190e06 --- /dev/null +++ b/src/mem/gems_common/ioutil/attrparse.yy @@ -0,0 +1,232 @@ +/* + Copyright (C) 1999-2005 by Mark D. Hill and David A. Wood for the + Wisconsin Multifacet Project. Contact: gems@cs.wisc.edu + http://www.cs.wisc.edu/gems/ + + -------------------------------------------------------------------- + + This file a component of the Multifacet GEMS (General + Execution-driven Multiprocessor Simulator) software toolset + originally developed at the University of Wisconsin-Madison. + + Ruby was originally developed primarily by Milo Martin and Daniel + Sorin with contributions from Ross Dickson, Carl Mauer, and Manoj + Plakal. + + SLICC was originally developed by Milo Martin with substantial + contributions from Daniel Sorin. + + Opal was originally developed by Carl Mauer based upon code by + Craig Zilles. + + Substantial further development of Multifacet GEMS at the + University of Wisconsin was performed by Alaa Alameldeen, Brad + Beckmann, Ross Dickson, Pacia Harper, Milo Martin, Michael Marty, + Carl Mauer, Kevin Moore, Manoj Plakal, Daniel Sorin, Min Xu, and + Luke Yen. + + -------------------------------------------------------------------- + + If your use of this software contributes to a published paper, we + request that you (1) cite our summary paper that appears on our + website (http://www.cs.wisc.edu/gems/) and (2) e-mail a citation + for your published paper to gems@cs.wisc.edu. + + If you redistribute derivatives of this software, we request that + you notify us and either (1) ask people to register with us at our + website (http://www.cs.wisc.edu/gems/) or (2) collect registration + information and periodically send it to us. + + -------------------------------------------------------------------- + + Multifacet GEMS is free software; you can redistribute it and/or + modify it under the terms of version 2 of the GNU General Public + License as published by the Free Software Foundation. + + Multifacet GEMS is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with the Multifacet GEMS; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307, USA + + The GNU General Public License is contained in the file LICENSE. + +### END HEADER ### +*/ + + + +%{ +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +#ifdef IS_RUBY +#include "Global.hh" +#endif + +using namespace std; +#include +#include +#include + +// Maurice +// extern "C" { +// #include "simics/api.h" +// }; + +#include "FakeSimicsDataTypes.hh" + +#include "confio.hh" + +// CM FIX: if I wasn't working on a paper: I'd re-write the grammer to +// be left (or right) recursive, which ever is more efficient +// This only affects extremely large cache sizes / BP sizes on read in. +#define YYMAXDEPTH 100000 + +extern char* attext; + +extern void aterror(const char *); +extern int atlex(); +attr_value_t g_attr_map; + +extern void fprintAttr( FILE *fp, attr_value_t attr ); + +%} + +/*------------------------------------------------------------------------*/ +/* Union declarations */ +/*------------------------------------------------------------------------*/ +// The types of the tokens and nonterminals +%union { + attr_value_t *attrval; +}; + +%token STRING INTEGER +%token MY_END LPAREN RPAREN + +%type confmapping confpair attributes attrlist +%% + +conffile : confmapping +{ + g_attr_map = *($1); + free( $1 ) +} + +confmapping : confmapping confpair +{ + attr_value_t *newattr = mallocAttribute(1); + newattr->kind = Sim_Val_List; + if ( $1 == NULL ) { + newattr->u.list.size = 1; + newattr->u.list.vector = $2; + } else { + // add the latest mapping to the return mapping + uint32 newsize = $1->u.list.size + 1; + attr_value_t *vector = mallocAttribute( newsize ); + newattr->u.list.size = newsize; + newattr->u.list.vector = vector; + for (uint32 i = 0; i < newsize - 1; i++) { + vector[i] = $1->u.list.vector[i]; + } + vector[newsize - 1] = *($2); + free( $1->u.list.vector ); + free( $1 ); + free( $2 ); + } + $$ = newattr; +} + | // nothing +{ + $$ = NULL; +} + +confpair : STRING ':' attributes +{ + attr_value_t *newattr = mallocAttribute(1); + newattr->kind = Sim_Val_List; + newattr->u.list.size = 2; + newattr->u.list.vector = mallocAttribute(2); + newattr->u.list.vector[0] = *($1); + newattr->u.list.vector[1] = *($3); + free( $1 ); + free( $3 ); + $$ = newattr; +} + +attributes : INTEGER +{ + $$ = $1; +} + | STRING +{ + $$ = $1; +} + | LPAREN attrlist RPAREN +{ + attr_value_t *newattr = mallocAttribute(1); + newattr->kind = Sim_Val_List; + if ( $2->kind != CONF_ATTR_SINGLE && + $2->kind != CONF_ATTR_PAIR ) { + newattr->u.list.size = 1; + newattr->u.list.vector = $2; + } else { + newattr->u.list.size = $2->u.list.size; + newattr->u.list.vector = mallocAttribute(newattr->u.list.size); + attr_value_t *curattr = $2; + uint32 i = 0; + while ( i < newattr->u.list.size ) { + if (curattr->kind == CONF_ATTR_SINGLE) { + newattr->u.list.vector[i] = curattr->u.list.vector[0]; + i++; + + curattr = NULL; + } else if (curattr->kind == CONF_ATTR_PAIR) { + newattr->u.list.vector[i] = curattr->u.list.vector[0]; + i++; + if ( i < newattr->u.list.size ) + curattr = &(curattr->u.list.vector[1]); + else + curattr = NULL; + + } else { + ERROR_OUT("error: unknown kind in pair: %d\n", curattr->kind); + ASSERT(0); + } + } + // FIX memory leak: around 600 KB + // freeAttribute( $2 ); // with gcc-3.4 this free call tries to free memory from the stack + } + $$ = newattr; +} + +attrlist : attributes +{ + attr_value_t *newattr = mallocAttribute(1); + newattr->kind = CONF_ATTR_SINGLE; + newattr->u.list.size = 1; + newattr->u.list.vector = $1; + $$ = newattr; +} + | attributes ',' attrlist +{ + // allocate the pair ( x , y ) attribute + attr_value_t *newattr = mallocAttribute(1); + int newsize = $3->u.list.size + 1; + attr_value_t *vector = mallocAttribute(2); + newattr->kind = CONF_ATTR_PAIR; + newattr->u.list.size = newsize; + newattr->u.list.vector = vector; + + // assign the LH attribute + vector[0] = *($1); + vector[1] = *($3); + free( $1 ); + free( $3 ); + $$ = newattr; +} diff --git a/src/mem/gems_common/ioutil/confio.cc b/src/mem/gems_common/ioutil/confio.cc new file mode 100644 index 000000000..68d44197a --- /dev/null +++ b/src/mem/gems_common/ioutil/confio.cc @@ -0,0 +1,456 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * saves configuration information for later runs + */ + +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +#ifdef IS_OPAL +#include "hfa.hh" +#endif + +#ifdef IS_RUBY +#include "Global.hh" +#define SIM_HALT ASSERT(0) +#endif + +#ifdef IS_TOURMALINE +#include "Tourmaline_Global.hh" +#endif + +using namespace std; +#include +#include +#include + +// Maurice +// extern "C" { +// #include "global.hh" +// #include "simics/api.hh" +// +// #ifdef SIMICS22X +// #include "sparc_api.hh" +// #endif +// #ifdef SIMICS30 +// #ifdef SPARC +// #include "sparc.hh" +// #else +// #include "x86.hh" +// #endif +// #endif +// }; + +#include "FakeSimicsDataTypes.hh" + +#include "confio.hh" + +/*------------------------------------------------------------------------*/ +/* Macro declarations */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Variable declarations */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Forward declarations */ +/*------------------------------------------------------------------------*/ + +// C++ Template: explicit instantiation +template class map; + +// These functions are defined in parser/attrlex.l +extern "C" int parseAttrFile( FILE *inputFile, const char *relative_include_path, attr_value_t *myTable ); +extern "C" int parseAttrString( const char *str, attr_value_t *myTable ); + +/*------------------------------------------------------------------------*/ +/* Constructor(s) / destructor */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +confio_t::confio_t( ) +{ + m_verbose = false; +} + +//************************************************************************** +confio_t::~confio_t( ) +{ + ConfTable::iterator iter; + + for ( iter = m_table.begin(); iter != m_table.end(); iter++ ) { + confnode_t *cfnode = (*iter).second; + free( cfnode ); + } +} + +/*------------------------------------------------------------------------*/ +/* Public methods */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Accessor(s) / mutator(s) */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +int confio_t::register_attribute( const char *name, + get_confio_t get_attr, void *get_attr_data, + set_confio_t set_attr, void *set_attr_data ) +{ + confnode_t *newnode; + if ( m_table.find(name) == m_table.end() ) { + if (m_verbose) + DEBUG_OUT(" registering checkpoint attribute: \"%s\"\n", name); + + // add a new entry to the table + newnode = (confnode_t *) malloc( sizeof( confnode_t ) ); + newnode->get_attr = get_attr; + newnode->set_attr = set_attr; + newnode->set_attr_data = set_attr_data; + newnode->get_attr_data = get_attr_data; + newnode->attr_is_set = false; + string key(name); + m_table[key] = newnode; + } else { + ERROR_OUT(" warning: confio: adding existing conf node: %s\n", name); + } + return 0; +} + +//************************************************************************** +void fprintAttr( FILE *fp, attr_value_t attr ) +{ + switch (attr.kind) { + case Sim_Val_Invalid: + fprintf(fp, "invalid"); + break; + + case Sim_Val_String: + fprintf(fp, "%s", attr.u.string); + break; + + case Sim_Val_Integer: + fprintf(fp, "0x%llx", attr.u.integer); + break; + + case Sim_Val_Floating: + fprintf(fp, "0x%llx", attr.u.integer); + break; + + case Sim_Val_List: + fprintf(fp, "("); + for (uint32 i = 0; i < attr.u.list.size; i++) { + fprintAttr(fp, attr.u.list.vector[i]); + if (i != attr.u.list.size -1) { + fprintf(fp, ", "); + } + } + fprintf(fp, ")"); + break; + + default: + ERROR_OUT("fprintAttr: unknown/unimplemented attribute %d\n", attr.kind); + } +} + +//************************************************************************** +void freeAttribute( attr_value_t *attr ) +{ + switch (attr->kind) { + case Sim_Val_Invalid: + break; + + case Sim_Val_String: + free( (char *) attr->u.string ); + break; + + case Sim_Val_Integer: + break; + + case Sim_Val_Floating: + break; + + case Sim_Val_List: + for (uint32 i = 0; i < attr->u.list.size; i++) { + freeAttribute( &(attr->u.list.vector[i]) ); + } + free( attr->u.list.vector ); + break; + + default: + ERROR_OUT("freeAttr: unknown/unimplemented attribute %d\n", attr->kind); + } +} + +/** + * Allocates, and initializes a attribute value. + * @param number The number of values to allocate. + * @return A pointer to the newly allocated structure. + */ +//************************************************************************** +attr_value_t *mallocAttribute( uint32 number ) +{ + attr_value_t *newattr = (attr_value_t *) malloc( number * + sizeof(attr_value_t) ); + if ( newattr == NULL ) { + ERROR_OUT( "confio: mallocAttribute: out of memory\n" ); + exit(1); + } + memset( newattr, 0, number*sizeof(attr_value_t) ); + return (newattr); +} + + +//************************************************************************** +void fprintMap( FILE *fp, attr_value_t attr ) +{ + attr_value_t name; + attr_value_t value; + + if (attr.kind != Sim_Val_List) + return; + + for (int i = 0; i < attr.u.list.size; i++) { + + if (attr.u.list.vector[i].kind != Sim_Val_List || + attr.u.list.vector[i].u.list.size != 2) + return; + + name = attr.u.list.vector[i].u.list.vector[0]; + value = attr.u.list.vector[i].u.list.vector[1]; + fprintf( fp, " %s: ", name.u.string); + fprintAttr( fp, value ); + fprintf( fp, "\n"); + } +} + +/** + * write a configuration file: e.g. save state + */ +//************************************************************************** +int confio_t::writeConfiguration( const char *outputFilename ) +{ + FILE *fp; + ConfTable::iterator iter; + confnode_t *cfnode; + attr_value_t attr; + + memset( &attr, 0, sizeof(attr_value_t) ); + if ( outputFilename == NULL ) { + fp = stdout; + } else { + fp = fopen( outputFilename, "w" ); + if ( fp == NULL ) { + ERROR_OUT("error: writeConfiguration: unable to open file %s\n", + outputFilename ); + return (-1); + } + } + + for (iter = m_table.begin(); iter != m_table.end(); iter++) { + fprintf( fp, " %s: ", (*iter).first.c_str() ); + cfnode = (*iter).second; + attr = (*(cfnode->get_attr))( cfnode->get_attr_data, NULL ); + fprintAttr( fp, attr ); + fprintf(fp, "\n"); + } + + if ( outputFilename != NULL ) { + // wrote to a file: now close it! + fclose( fp ); + } + return 0; +} + +/** + * read state from an existing configuration file + */ +//************************************************************************** +int confio_t::readConfiguration( const char *inputFilename, + const char *relativeIncludePath ) +{ + // parse the input stream + FILE *fp; + char relativeFilename[256]; + + fp = fopen( inputFilename, "r" ); + if ( fp == NULL ) { + sprintf( relativeFilename, "%s%s", relativeIncludePath, inputFilename ); + fp = fopen( relativeFilename, "r" ); + } + if ( fp == NULL ) { + sprintf( relativeFilename, "%s%s%s", relativeIncludePath, "config/", + inputFilename ); + fp = fopen( relativeFilename, "r" ); + } + if ( fp == NULL ) { + ERROR_OUT("error: readConfiguration: unable to open file %s or %s\n", + inputFilename, relativeFilename); + return (-1); + } + + attr_value_t *myattr = mallocAttribute(1); +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() parsing conf file\n"); +#endif + int rc = parseAttrFile( fp, relativeIncludePath, myattr ); +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() parse completed\n"); +#endif + if ( rc == 0 ) { + applyConfiguration( myattr ); + freeAttribute( myattr ); + free(myattr); + } + + fclose( fp ); +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() completed\n"); +#endif + return (rc); +} + +/** + * read state from a configuration string + */ +//************************************************************************** +int confio_t::readConfigurationString( const char *inputBuffer ) +{ + if ( inputBuffer == NULL ) { + ERROR_OUT( "error: readConfiguration: NULL inputBuffer\n" ); + return (-1); + } + + attr_value_t *myattr = mallocAttribute(1); +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() parsing conf string\n"); +#endif + + int rc = parseAttrString( inputBuffer, myattr ); +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() parse completed\n"); +#endif + if ( rc == 0 ) { + applyConfiguration( myattr ); + freeAttribute( myattr ); + free(myattr); + } + return (rc); +} + +//************************************************************************** +void confio_t::checkInitialization( void ) +{ + ConfTable::iterator iter; + confnode_t *cfnode; + + for (iter = m_table.begin(); iter != m_table.end(); iter++) { + cfnode = (*iter).second; + if ( !cfnode->attr_is_set ) { + DEBUG_OUT(" warning: %s is not set in configuration file.\n", (*iter).first.c_str() ); + } + } +} + +/*------------------------------------------------------------------------*/ +/* Private methods */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +int confio_t::applyConfiguration( attr_value_t *attr ) +{ + confnode_t *cfnode; + attr_value_t name; + attr_value_t value; + set_error_t seterr; + +#ifdef MODINIT_VERBOSE + DEBUG_OUT("confio_t() data in memory\n"); + fprintMap( stdout, *attr ); +#endif + + // apply the configuration the the m_table + if (attr->kind != Sim_Val_List || + attr->u.list.size <= 0) { + ERROR_OUT("readconfiguration: internal error #1\n"); + return -1; + } + + for (int i = 0; i < attr->u.list.size; i++) { + + if (attr->u.list.vector[i].kind != Sim_Val_List || + attr->u.list.vector[i].u.list.size != 2) { + ERROR_OUT("readconfiguration: illegal configuration kind:%d size:%lld\n", + attr->u.list.vector[i].kind, + attr->u.list.vector[i].u.list.size); + continue; + } + + name = attr->u.list.vector[i].u.list.vector[0]; + value = attr->u.list.vector[i].u.list.vector[1]; + string newstr((char *) name.u.string); + if ( m_table.find(newstr) != m_table.end()) { + + // set the value found in the configuration + cfnode = m_table[newstr]; + seterr = (*cfnode->set_attr)( cfnode->set_attr_data, NULL, + &(value) ); + if ( seterr == Sim_Set_Ok ) { + cfnode->attr_is_set = true; + if (m_verbose) + DEBUG_OUT("configuration set for: %s\n", name.u.string); + } else { + ERROR_OUT("error: \"%s\" unable to set value: %d\n", + name.u.string, (int) seterr); + } + } else { + ERROR_OUT("error: \"%s\" not found. unable to set value.\n", + name.u.string); + } + } + return 0; +} + +/*------------------------------------------------------------------------*/ +/* Static methods */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Global functions */ +/*------------------------------------------------------------------------*/ + + +/** [Memo]. + * [Internal Documentation] + */ +//************************************************************************** + diff --git a/src/mem/gems_common/ioutil/confio.hh b/src/mem/gems_common/ioutil/confio.hh new file mode 100644 index 000000000..143c4da8b --- /dev/null +++ b/src/mem/gems_common/ioutil/confio.hh @@ -0,0 +1,192 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _CONFIO_H_ +#define _CONFIO_H_ + +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +#include "FakeSimicsDataTypes.hh" + +/*------------------------------------------------------------------------*/ +/* Macro declarations */ +/*------------------------------------------------------------------------*/ + +/// constant for attribute parsing: a (x) single value +const attr_kind_t CONF_ATTR_SINGLE = (attr_kind_t) (Sim_Val_Object + 1); +/// constant for attribute parsing: a (x,y) pair of values +const attr_kind_t CONF_ATTR_PAIR = (attr_kind_t) (Sim_Val_Object + 2); + +/*------------------------------------------------------------------------*/ +/* Class declaration(s) */ +/*------------------------------------------------------------------------*/ + +/* + * Functions for modifying the micro-architectural configuation of + * a class. + */ + +/// function for getting the configuration value +typedef attr_value_t (*get_confio_t)( void *ptr, void *obj ); +/// function for setting the configuration value +typedef set_error_t (*set_confio_t)( void *ptr, void *obj, + attr_value_t *value ); + +/// a struture containing the functional callbacks for each conf node +typedef struct confnode { + get_confio_t get_attr; + set_confio_t set_attr; + void *set_attr_data; + void *get_attr_data; + bool attr_is_set; +} confnode_t; + +/// a mapping from a string to a configuration structure +typedef map ConfTable; + +/** +* Configuration state saving: allows the user to save the micro-architectural +* state in a text file for later runs. This file is also used to set +* globals during simulation. +* +* @author cmauer +* @version $Id$ +*/ +class confio_t { + +public: + + + /** + * @name Constructor(s) / destructor + */ + //@{ + + /** + * Constructor: creates object + */ + confio_t(); + + /** + * Destructor: frees object. + */ + ~confio_t(); + //@} + + /** + * @name Methods + */ + //@{ + //@} + + /** + * @name Accessor(s) / mutator(s) + */ + //@{ + /** + * register a configuration variable with the configuration manager. + * @param get_attr A function to get the attribute value + * @param get_attr_data Void pointer, available to get_attr + * @param set_attr A function to set the attribute value + * @param set_attr_data Void pointer, available to set_attr + * @return [Description of return value] + */ + int register_attribute( const char *name, + get_confio_t get_attr, void *get_attr_data, + set_confio_t set_attr, void *set_attr_data ); + + /** + * Set verbosity of the configuration + * @param verbose True causes more info to be printed out, False doesn't + */ + void setVerbosity( bool verbose ) { + m_verbose = verbose; + } + + /** + * write a configuration file: e.g. save state + */ + int writeConfiguration( const char *outputFilename ); + + /** + * read state from an existing configuration file + * @param inputFilename The file to read + * @param relativeIncludePath The path to search on 'include' statements + */ + int readConfiguration( const char *inputFilename, + const char *relativeIncludePath ); + + /** + * read state from a string + */ + int readConfigurationString( const char *inputBuffer ); + + /** + * check that each registered configuration is set (reports a warning if + * they are not.) + */ + void checkInitialization( void ); + //@} + +private: + /** + * Apply an attribute list to the configuration table + */ + int applyConfiguration( attr_value_t *attr ); + + /// configuration table: contains a map from a string -> conf node + ConfTable m_table; + + /// if false, nothing is printed under normal operation + bool m_verbose; +}; + +/*------------------------------------------------------------------------*/ +/* Global variables */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Global functions */ +/*------------------------------------------------------------------------*/ + +/** + * Allocates an array of attributes. + */ +attr_value_t *mallocAttribute( uint32 number ); + +/** + * Walks an attribute tree, freeing all memory under attr. Does not free + * attr itself. + */ +void freeAttribute( attr_value_t *attr ); + +#endif /* _CONFIO_H_ */ + + diff --git a/src/mem/gems_common/ioutil/embedtext.py b/src/mem/gems_common/ioutil/embedtext.py new file mode 100644 index 000000000..64e1c97f3 --- /dev/null +++ b/src/mem/gems_common/ioutil/embedtext.py @@ -0,0 +1,54 @@ + +import sys + +#--------------------------------------------------------------------------- + +class embedText: + """ + embedText converts a text file into a file that can be embedded in C + using an #include statement, that defines a \"const char *\" pointing + to the same text. + + This is useful to embed scripts and configuration files in object files. + """ + def __init__(self, filename): + self.filename = filename + self.escape = [ "\'", "\"", "\\", "\?" ] + + def write(self, outputfile, varname): + # reads the text file in, line by line, converting it to a C string + fin = open( self.filename, 'r' ) + fout= open( outputfile, 'w' ) + fout.write("static const char *%s =\n" % varname); + l = " " + while l != "": + l = fin.readline() + + # add escape sequences for the characters in escape + fout.write("\"") + for char in l: + if char == "\n": + break + if char in self.escape: + fout.write( "\\" ) + fout.write( char ) + else: + fout.write( char ) + fout.write("\\n\"\n"); + fout.write(";\n"); + fin.close() + fout.close() + +#--------------------------------------------------------------------------- + +if __name__ == "__main__": + if len(sys.argv) != 4: + print len(sys.argv) + print "usage:", sys.argv[0], " input-file output-file varname" + sys.exit(1) + inputfile = sys.argv[1] + outputfile = sys.argv[2] + varname = sys.argv[3] + print "generating embedded text file: %s from %s\n" % (outputfile, inputfile) + inc = embedText( inputfile ) + inc.write( outputfile, varname ) diff --git a/src/mem/gems_common/ioutil/initvar.cc b/src/mem/gems_common/ioutil/initvar.cc new file mode 100644 index 000000000..9cccdf64b --- /dev/null +++ b/src/mem/gems_common/ioutil/initvar.cc @@ -0,0 +1,626 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + This file has been modified by Kevin Moore and Dan Nussbaum of the + Scalable Systems Research Group at Sun Microsystems Laboratories + (http://research.sun.com/scalable/) to support the Adaptive + Transactional Memory Test Platform (ATMTP). + + Please send email to atmtp-interest@sun.com with feedback, questions, or + to request future announcements about ATMTP. + + ---------------------------------------------------------------------- + + File modification date: 2008-02-23 + + ---------------------------------------------------------------------- +*/ + +/* + * FileName: initvar.C + * Synopsis: implementation of global variable initialization in simics + * Author: cmauer + * Version: $Id$ + */ + +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +using namespace std; +#include +#include +#include + +// Maurice +// extern "C" { +// #include "global.hh" +// #include "simics/api.hh" +// #ifdef SIMICS22X +// #include "configuration_api.hh" +// #endif +// #ifdef SIMICS30 +// #include "configuration.hh" +// #endif +// }; + +#include "FakeSimicsDataTypes.hh" + +#ifdef IS_OPAL +#include "hfatypes.hh" +#include "debugio.hh" +#endif + +#ifdef IS_RUBY +#include "Global.hh" +#endif + +#ifdef IS_TOURMALINE +#include "Tourmaline_Global.hh" +#endif + +#include "confio.hh" +#include "initvar.hh" + +/*------------------------------------------------------------------------*/ +/* Macro declarations */ +/*------------------------------------------------------------------------*/ + +#define CONFIG_VAR_FILENAME "config.include" + +/*------------------------------------------------------------------------*/ +/* Variable declarations */ +/*------------------------------------------------------------------------*/ + +// define global "constants" using centralized file +#define PARAM( NAME ) \ + int32 NAME; +#define PARAM_UINT( NAME ) \ + uint32 NAME; +#define PARAM_ULONG( NAME ) \ + uint64 NAME; +#define PARAM_BOOL( NAME ) \ + bool NAME; +#define PARAM_DOUBLE( NAME ) \ + double NAME; +#define PARAM_STRING( NAME ) \ + char *NAME; +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + PTYPE NAME[ARRAY_SIZE]; +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + +/** global initvar object */ +initvar_t *initvar_t::m_inst = NULL; + +/*------------------------------------------------------------------------*/ +/* Forward declarations */ +/*------------------------------------------------------------------------*/ + +static attr_value_t initvar_get_attr( void *ptr, void *obj ); +static set_error_t initvar_set_attr( void *ptr, void *obj, + attr_value_t *value ); + +/*------------------------------------------------------------------------*/ +/* Constructor(s) / destructor */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +initvar_t::initvar_t( const char *name, const char *relativeIncludePath, + const char *initializingString, + void (*allocate_fn)(void), + void (*my_generate_fn)(void), + get_attr_t my_get_attr, set_attr_t my_set_attr ) +{ + m_is_init = false; + m_name = (char *) malloc( sizeof(char)*(strlen( name ) + 2) ); + m_rel_include_path = (char *) malloc( sizeof(char)*(strlen( relativeIncludePath ) + 2) ); + m_config_filename = NULL; + strcpy( m_name, name ); + strcpy( m_rel_include_path, relativeIncludePath ); + m_allocate_f = allocate_fn; + m_generate_values_f = my_generate_fn; + m_my_get_attr = my_get_attr; + m_my_set_attr = my_set_attr; + + initvar_t::m_inst = this; + init_config_reader( initializingString ); +} + +//************************************************************************** +initvar_t::~initvar_t( ) +{ +#define PARAM( NAME ) +#define PARAM_UINT( NAME ) +#define PARAM_ULONG( NAME ) +#define PARAM_BOOL( NAME ) +#define PARAM_DOUBLE( NAME ) +#define PARAM_STRING( NAME ) \ + if (NAME != NULL) { \ + free( NAME ); \ + NAME = NULL; \ + } +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + if (m_name) { + free( m_name ); + } + if (m_rel_include_path) { + free( m_rel_include_path ); + } + if (m_config_reader) { + delete m_config_reader; + } + if (m_config_filename) { + delete m_config_filename; + } +} + +//************************************************************************** +void initvar_t::init_config_reader( const char *initString ) +{ + int rc; + const char *name; + + m_config_reader = new confio_t(); + m_config_reader->setVerbosity( false ); + + // Initialize the config reader object to identify each parameter +#define PARAM_UINT PARAM +#define PARAM_ULONG PARAM +#define PARAM_BOOL PARAM +#define PARAM_DOUBLE PARAM +#define PARAM( NAME ) \ + name = #NAME; \ + rc = m_config_reader->register_attribute( name, \ + initvar_get_attr, (void *) name, \ + initvar_set_attr, (void *) name ); +#define PARAM_STRING( NAME ) \ + NAME = NULL; \ + name = #NAME; \ + rc = m_config_reader->register_attribute( name, \ + initvar_get_attr, (void *) name, \ + initvar_set_attr, (void *) name ); +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + name = #NAME; \ + rc = m_config_reader->register_attribute( name, \ + initvar_get_attr, (void *) name, \ + initvar_set_attr, (void *) name ); + +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + + // read the default configuration from the embedded text file + rc = m_config_reader->readConfigurationString( initString ); + (*m_generate_values_f)(); +} + +/*------------------------------------------------------------------------*/ +/* Public methods */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +void initvar_t::allocate( void ) +{ + if ( confirm_init() ) { + DEBUG_OUT("error: %s initvar::allocate() called twice\n", m_name); + return; + } + + (*m_generate_values_f)(); + (*m_allocate_f)(); + m_is_init = true; +} + +//************************************************************************** +void initvar_t::checkInitialization( void ) +{ + m_config_reader->checkInitialization(); +} + +//************************************************************************** +attr_value_t initvar_t::dispatch_get( void *id, void *obj, + attr_value_t *idx ) +{ + const char *command = (const char *) id; + if ( !confirm_init() ) { + DEBUG_OUT("error: %s is uninitialized. unable to get \'%s\'\n", m_name, command); + DEBUG_OUT(" : you must initialize %s with a configuration file first.\n", m_name); + DEBUG_OUT(" : use the command \'%s0.init\'\n", m_name); + + attr_value_t ret; + ret.kind = Sim_Val_Invalid; + ret.u.integer = 0; + return ret; + } + + return ((*m_my_get_attr)(id, obj, idx)); +} + + +//************************************************************************** +set_error_t initvar_t::dispatch_set( void *id, void *obj, + attr_value_t *val, attr_value_t *idx ) +{ + const char *command = (const char *) id; + + // DEBUG_OUT("set attribute: %s\n", command); + if (!strcmp(command, "init")) { + if (val->kind == Sim_Val_String) { + if (!strcmp( val->u.string, "" )) { + // update generated values, then allocate + allocate(); + } else { + read_config( val->u.string ); + allocate(); + } + return Sim_Set_Ok; + } else { + return Sim_Set_Need_String; + } + } else if (!strcmp(command, "readparam")) { + if (val->kind == Sim_Val_String) { + read_config( val->u.string ); + return Sim_Set_Ok; + } else { + return Sim_Set_Need_String; + } + } else if (!strcmp(command, "saveparam")) { + if (val->kind == Sim_Val_String) { + FILE *fp = fopen( val->u.string, "w" ); + if (fp == NULL) { + ERROR_OUT("error: unable to open file: %s\n", val->u.string); + return Sim_Set_Illegal_Value; + } + list_param( fp ); + if (fp != NULL) { + fclose( fp ); + } + return Sim_Set_Ok; + } else { + ERROR_OUT("error: saveparam given wrong type.\n"); + return Sim_Set_Illegal_Value; + } + } else if (!strcmp(command, "param")) { + if (val->kind == Sim_Val_Integer) { + list_param( stdout ); + return Sim_Set_Ok; + } else if ( val->kind == Sim_Val_List && + val->u.list.size == 2 && + val->u.list.vector[0].kind == Sim_Val_String ) { + return (set_param( val->u.list.vector[0].u.string, + &val->u.list.vector[1] )); + } else { + DEBUG_OUT("error: set parameter given wrong type.\n"); + return Sim_Set_Illegal_Value; + } + } + + if ( !confirm_init() ) { + DEBUG_OUT("error: %s is uninitialized. unable to set \'%s\'\n", m_name, id); + DEBUG_OUT(" : you must initialize %s with a configuration file first.\n", m_name); + DEBUG_OUT(" : use the command \'%s0.init\'\n", m_name); + return Sim_Set_Illegal_Value; + } + + return (*m_my_set_attr)( id, obj, val, idx ); +} + +/*------------------------------------------------------------------------*/ +/* Accessor(s) / mutator(s) */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Private methods */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Static methods */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +static attr_value_t initvar_get_attr( void *ptr, void *obj ) +{ + const char *name = (const char *) ptr; + attr_value_t ret; + memset( &ret, 0, sizeof(attr_value_t) ); + +#define PARAM_UINT PARAM +#define PARAM_ULONG PARAM +#define PARAM_BOOL PARAM +#define PARAM( NAME ) \ + if (!strcmp(name, #NAME)) { \ + ret.kind = Sim_Val_Integer; \ + ret.u.integer = NAME; \ + return (ret); \ + } +#define PARAM_DOUBLE( NAME ) \ + if (!strcmp(name, #NAME)) { \ + ret.kind = Sim_Val_Floating; \ + ret.u.floating = NAME; \ + return (ret); \ + } +#define PARAM_STRING( NAME ) \ + if (!strcmp(name, #NAME)) { \ + ret.kind = Sim_Val_String; \ + ret.u.string = NAME; \ + return (ret); \ + } +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + if (!strcmp(name, #NAME)) { \ + ret.kind = Sim_Val_List; \ + ret.u.list.size = ARRAY_SIZE; \ + ret.u.list.vector = mallocAttribute( ARRAY_SIZE ); \ + for (int i = 0; i < ARRAY_SIZE; i++) { \ + ret.u.list.vector[i].u.integer = NAME[i]; \ + } \ + return (ret); \ + } + +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + + DEBUG_OUT("error: %s not found.\n", name); + ret.kind = Sim_Val_Invalid; + return (ret); +} + +//*************************************************************************** +static set_error_t initvar_set_attr( void *ptr, void *obj, + attr_value_t *value ) +{ + const char *name = (const char *) ptr; + +#define PARAM_UINT PARAM +#define PARAM_ULONG PARAM +#define PARAM( NAME ) \ + if (!strcmp(name, #NAME)) { \ + if ( value->kind != Sim_Val_Integer ) { \ + ERROR_OUT("error: %s is not an integer\n", name );\ + return Sim_Set_Need_Integer; \ + } \ + NAME = value->u.integer; \ + return Sim_Set_Ok; \ + } +#define PARAM_BOOL( NAME ) \ + if (!strcmp(name, #NAME)) { \ + if ( value->kind != Sim_Val_String ) { \ + ERROR_OUT("error: %s is not an bool string\n", name );\ + return Sim_Set_Need_String; \ + } \ + if (!strcmp(value->u.string, "true")) { \ + NAME = true; \ + } else if (!strcmp(value->u.string, "false")) { \ + NAME = false; \ + } else { \ + ERROR_OUT("error: value %s for %s is not an bool string (set to false)\n", value->u.string, name );\ + NAME = false; \ + } \ + return Sim_Set_Ok; \ + } +#define PARAM_DOUBLE( NAME ) \ + if (!strcmp(name, #NAME)) { \ + if ( value->kind != Sim_Val_String ) { \ + ERROR_OUT("error: %s is not a float\n", name );\ + return Sim_Set_Need_Floating; \ + } \ + NAME = atof( value->u.string ); \ + return Sim_Set_Ok; \ + } +#define PARAM_STRING( NAME ) \ + if (!strcmp(name, #NAME)) { \ + if ( value->kind != Sim_Val_String ) { \ + ERROR_OUT("error: %s is not an string\n", name ); \ + return Sim_Set_Need_String; \ + } \ + if (NAME != NULL) { \ + free( NAME ); \ + } \ + NAME = strdup( value->u.string ); \ + return Sim_Set_Ok; \ + } +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + if (!strcmp(name, #NAME)) { \ + if ( value->kind != Sim_Val_List ) { \ + ERROR_OUT("error: %s is not an list\n", name ); \ + return Sim_Set_Need_List; \ + } \ + if ( value->u.list.size != ARRAY_SIZE ) { \ + ERROR_OUT("error: %s has %lld elements (should be %d)\n", name, value->u.list.size, ARRAY_SIZE); \ + return Sim_Set_Illegal_Value; \ + } \ + for (int i = 0; i < ARRAY_SIZE; i++) { \ + NAME[i] = value->u.list.vector[i].u.integer; \ + } \ + return Sim_Set_Ok; \ + } + +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + + ERROR_OUT("error: %s not a parameter\n", name); + return Sim_Set_Illegal_Value; +} + +//*************************************************************************** +void initvar_t::read_config( const char *parameterFile ) +{ + DEBUG_OUT("read configuration: %s\n", parameterFile ); + m_config_filename = strdup( parameterFile ); + int rc = m_config_reader->readConfiguration( parameterFile, + m_rel_include_path ); + if ( rc < 0 ) { + ERROR_OUT("fatal error in read configuration: unable to continue.\n"); + exit(1); + } + // update generated values + (*m_generate_values_f)(); +} + +/** sets one of the parameters */ +//************************************************************************** +set_error_t initvar_t::set_param( const char *name, attr_value_t *value ) +{ + + // [dann 2007-04-04] ATMTP VV + // + // HACK ALERT: allow setting REMOVE_SINGLE_CYCLE_DCACHE_FAST_PATH, + // PROFILE_EXCEPTIONS, PROFILE_XACT, ATMTP_DEBUG_LEVEL and + // ATMTP_ENABLED after initialization. This works is because ruby's + // m_generate_values_f() does nothing -- more particularly, nothing + // that depends on any of these parameters is pre-calculated + // anywhere. + // + if (strcmp(name, "REMOVE_SINGLE_CYCLE_DCACHE_FAST_PATH") != 0 && + strcmp(name, "PROFILE_EXCEPTIONS") != 0 && + strcmp(name, "PROFILE_XACT") != 0 && + strcmp(name, "ATMTP_DEBUG_LEVEL") != 0 && + strcmp(name, "ATMTP_ENABLED") != 0) { + // + // [dann 2007-04-04] ATMTP ^^ + if ( confirm_init() ) { + DEBUG_OUT("error: %s is already initialized.\n", m_name); + DEBUG_OUT(" : setting parameters after initialization is unsupported\n"); + return (Sim_Set_Illegal_Value); + } + // [dann 2007-04-04] ATMTP VV + // + } + // + // [dann 2007-04-04] ATMTP ^^ + + set_error_t result = initvar_set_attr( (void *) name, NULL, value ); + (*m_generate_values_f)(); + return (result); +} + +/** print out a list of valid parameters */ +//************************************************************************** +void initvar_t::list_param( FILE *fp ) +{ + if (!fp) + fp = stdout; + +#define PARAM( NAME ) \ + fprintf( fp, "%-44.44s: %26d\n", #NAME, NAME ); +#define PARAM_UINT( NAME ) \ + fprintf( fp, "%-44.44s: %26u\n", #NAME, NAME ); +#define PARAM_ULONG( NAME ) \ + fprintf( fp, "%-44.44s: %26llu\n", #NAME, NAME ); +#define PARAM_BOOL( NAME ) \ + if (NAME == true) { \ + fprintf( fp, "%-44.44s: %26.26s\n", #NAME, "true" ); \ + } else { \ + fprintf( fp, "%-44.44s: %26.26s\n", #NAME, "false" );\ + } +#define PARAM_DOUBLE( NAME ) \ + fprintf( fp, "%-44.44s: %26f\n", #NAME, NAME ); +#define PARAM_STRING( NAME ) \ + if ( NAME != NULL ) { \ + fprintf( fp, "%-44.44s: %26.26s\n", #NAME, NAME ); \ + } +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + fprintf( fp, "%-44.44s: (", #NAME ); \ + for (int i = 0; i < ARRAY_SIZE; i++) { \ + if ( i != 0 ) { \ + fprintf( fp, ", " ); \ + } \ + fprintf( fp, "%d", NAME[i] ); \ + } \ + fprintf( fp, ")\n" ); + +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY +} + +//************************************************************************** +const char *initvar_t::get_config_name( void ) +{ + if (m_config_filename == NULL) { + return "default"; + } + return m_config_filename; +} + +/*------------------------------------------------------------------------*/ +/* Global functions */ +/*------------------------------------------------------------------------*/ + +//************************************************************************** +attr_value_t initvar_dispatch_get( void *id, void *obj, + attr_value_t *idx ) +{ + initvar_t *init_obj = initvar_t::m_inst; + return (init_obj->dispatch_get( id, obj, idx )); +} + +//************************************************************************** +set_error_t initvar_dispatch_set( void *id, void *obj, + attr_value_t *val, attr_value_t *idx ) +{ + initvar_t *init_obj = initvar_t::m_inst; + return (init_obj->dispatch_set( id, obj, val, idx )); +} diff --git a/src/mem/gems_common/ioutil/initvar.hh b/src/mem/gems_common/ioutil/initvar.hh new file mode 100644 index 000000000..8dea8dfc1 --- /dev/null +++ b/src/mem/gems_common/ioutil/initvar.hh @@ -0,0 +1,181 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _INCLUDE_H_ +#define _INCLUDE_H_ + +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Macro declarations */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Class declaration(s) */ +/*------------------------------------------------------------------------*/ + +/** +* This class deals with initializing the global variables in the object, +* setting the varibles (from the command line), printing the configuration, +* and saving it to a file. +* +* Before including this file, you must define the variable CONFIG_VAR_FILENAME +* to define which variables are to be used. +* +* @see confio_t +* @author cmauer +* @version $Id$ +*/ +class initvar_t { +public: + /** + * @name Constructor(s) / destructor + */ + //@{ + + /** + * Constructor: creates object + * @param name The name of this object + * @param relativeIncludePath The relative path to config files + * @param initializingString A string (with value pairs) for initialization + * @param allocate_f A ptr to the allocate function + * @param generate_values A ptr to the generate values function + * @param my_get_attr A ptr to the get attribute function + * @param my_set_attr A ptr to the set attribute function + */ + initvar_t( const char *name, const char *relativeIncludePath, + const char *initializingString, + void (*allocate_fn)(void), + void (*my_generate_fn)(void), + get_attr_t my_get_attr, set_attr_t my_set_attr ); + + /** + * Destructor: frees object. + */ + ~initvar_t(); + //@} + + /** + * @name Methods + */ + //@{ + /// calls the allocation routine explicitly (used by the tester) + void allocate( void ); + + /// checks to see if all vars have been initialized + void checkInitialization( void ); + + /// list all parameters: to a file (or stdout if file is NULL) + void list_param( FILE *fp ); + + /// returns the name of the last config file to be read ("default" is none) + const char *get_config_name( void ); + + /// calls through to the get_attr function, if object is initialized + attr_value_t dispatch_get( void *id, void *obj, + attr_value_t *idx ); + + /** adds initialization attributes, calls through to the set_attr function, + * if object is initialized. + */ + set_error_t dispatch_set( void *id, void *obj, + attr_value_t *val, attr_value_t *idx ); + //@} + /// (single) instance of the init var object + static initvar_t *m_inst; + +protected: + ///returns true if the variables are initialized + bool confirm_init( void ) { + return m_is_init; + } + + ///read a configuration file + void read_config( const char *parameterFile ); + + /// set a parameter to be a particular value + set_error_t set_param( const char *name, attr_value_t *value ); + + /// initializes the configuration reader + void init_config_reader( const char *initString ); + + /// bool value (true if initialized) + bool m_is_init; + + /// configuration reader + confio_t *m_config_reader; + + /// a pointer to a string (corresponding to this objects name) + char *m_name; + + /// a pointer to a string (representing the last config file read) + char *m_config_filename; + + /// the relative include path to the configuration files + char *m_rel_include_path; + + /// a pointer to the allocation function + void (*m_allocate_f)(void); + + /// a pointer to the generate values function + void (*m_generate_values_f)(void); + + /// a pointer to the session get function + get_attr_t m_my_get_attr; + /// a pointer to the session set function + set_attr_t m_my_set_attr; +}; + + +/*------------------------------------------------------------------------*/ +/* Global variables */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Global functions */ +/*------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" { +#endif + +///provides a dispatch mechanism that catches a few commands to get variables +attr_value_t initvar_dispatch_get( void *id, void *obj, + attr_value_t *idx ); + +///provides a dispatch mechanism that catches a few commands to set variables +set_error_t initvar_dispatch_set( void *id, void *obj, + attr_value_t *val, attr_value_t *idx ); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif /* _INCLUDE_H_ */ diff --git a/src/mem/gems_common/ioutil/vardecl.hh b/src/mem/gems_common/ioutil/vardecl.hh new file mode 100644 index 000000000..21bc62d02 --- /dev/null +++ b/src/mem/gems_common/ioutil/vardecl.hh @@ -0,0 +1,75 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _VARDECL_H_ +#define _VARDECL_H_ + +/*------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Macro declarations */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Class declaration(s) */ +/*------------------------------------------------------------------------*/ + +/*------------------------------------------------------------------------*/ +/* Global variables */ +/*------------------------------------------------------------------------*/ + +#define PARAM( NAME ) \ + extern int32 NAME; +#define PARAM_UINT( NAME ) \ + extern uint32 NAME; +#define PARAM_ULONG( NAME ) \ + extern uint64 NAME; +#define PARAM_BOOL( NAME ) \ + extern bool NAME; +#define PARAM_DOUBLE( NAME ) \ + extern double NAME; +#define PARAM_STRING( NAME ) \ + extern char *NAME; +#define PARAM_ARRAY( PTYPE, NAME, ARRAY_SIZE ) \ + extern PTYPE NAME[ARRAY_SIZE]; +#include CONFIG_VAR_FILENAME +#undef PARAM +#undef PARAM_UINT +#undef PARAM_ULONG +#undef PARAM_BOOL +#undef PARAM_DOUBLE +#undef PARAM_STRING +#undef PARAM_ARRAY + +/*------------------------------------------------------------------------*/ +/* Global functions */ +/*------------------------------------------------------------------------*/ + +#endif /* _VARDECL_H_ */ diff --git a/src/mem/gems_common/std-includes.hh b/src/mem/gems_common/std-includes.hh new file mode 100644 index 000000000..619214f1d --- /dev/null +++ b/src/mem/gems_common/std-includes.hh @@ -0,0 +1,51 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef INCLUDES_H +#define INCLUDES_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace __gnu_cxx; + +#endif //INCLUDES_H diff --git a/src/mem/gems_common/util.cc b/src/mem/gems_common/util.cc new file mode 100644 index 000000000..c5b8f22b5 --- /dev/null +++ b/src/mem/gems_common/util.cc @@ -0,0 +1,109 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * $Id$ + */ + +#include "assert.h" +#include "util.hh" + +// Split a string into a head and tail strings on the specified +// character. Return the head and the string passed in is modified by +// removing the head, leaving just the tail. + +string string_split(string& str, char split_character) +{ + string head = ""; + string tail = ""; + + uint counter = 0; + while(counter < str.size()) { + if (str[counter] == split_character) { + counter++; + break; + } else { + head += str[counter]; + } + counter++; + } + + while(counter < str.size()) { + tail += str[counter]; + counter++; + } + str = tail; + return head; +} + +string bool_to_string(bool value) +{ + if (value) { + return "true"; + } else { + return "false"; + } +} + +string int_to_string(int n, bool zero_fill, int width) +{ + ostringstream sstr; + if(zero_fill) { + sstr << setw(width) << setfill('0') << n; + } else { + sstr << n; + } + string str = sstr.str(); + return str; +} + +float string_to_float(string& str) +{ + stringstream sstr(str); + float ret; + sstr >> ret; + return ret; +} + +// Log functions +int log_int(long long n) +{ + assert(n > 0); + int counter = 0; + while (n >= 2) { + counter++; + n = n>>(long long)(1); + } + return counter; +} + +bool is_power_of_2(long long n) +{ + return (n == ((long long)(1) << log_int(n))); +} + diff --git a/src/mem/gems_common/util.hh b/src/mem/gems_common/util.hh new file mode 100644 index 000000000..d9e9fec3e --- /dev/null +++ b/src/mem/gems_common/util.hh @@ -0,0 +1,68 @@ +/* + * Copyright (c) 1999-2005 Mark D. Hill and David A. Wood + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * $Id$ + */ + +#ifndef UTIL_H +#define UTIL_H + +#include "std-includes.hh" + +string string_split(string& str, char split_character); +string bool_to_string(bool value); +string int_to_string(int n, bool zero_fill = false, int width = 0); +float string_to_float(string& str); +int log_int(long long n); +bool is_power_of_2(long long n); + +// Min and Max functions (since they are extern inline, they are as +// fast as macros) + +extern inline +int max(int n1, int n2) +{ + if (n1 > n2) { + return n1; + } else { + return n2; + } +} + +extern inline +int min(int n1, int n2) +{ + if (n1 < n2) { + return n1; + } else { + return n2; + } +} + +#endif //UTIL_H -- cgit v1.2.3