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/ruby/common/Set.hh | 149 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 src/mem/ruby/common/Set.hh (limited to 'src/mem/ruby/common/Set.hh') diff --git a/src/mem/ruby/common/Set.hh b/src/mem/ruby/common/Set.hh new file mode 100644 index 000000000..7c33c840d --- /dev/null +++ b/src/mem/ruby/common/Set.hh @@ -0,0 +1,149 @@ + +/* + * Copyright (c) 1999-2008 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. + */ + +/* + * Set.h + * + * Description: + * + * $Id$ + * + */ + +// Define this to use the BigSet class which is slower, but supports +// sets of size larger than 32. + +// #define BIGSET + +#define OPTBIGSET + +#ifdef OPTBIGSET +#include "OptBigSet.hh" +#else + +#ifdef BIGSET +#include "BigSet.hh" // code to supports sets larger than 32 +#else + +#ifndef SET_H +#define SET_H + +#include "Global.hh" +#include "Vector.hh" +#include "NodeID.hh" +#include "RubyConfig.hh" + +class Set { +public: + // Constructors + // creates and empty set + Set(); + Set(int size); + + // used during the replay mechanism + // Set(const char *str); + + // Set(const Set& obj); + // Set& operator=(const Set& obj); + + // Destructor + // ~Set(); + + // Public Methods + + void add(NodeID newElement); + void addSet(const Set& set); + void addRandom(); + void remove(NodeID newElement); + void removeSet(const Set& set); + void clear(); + void broadcast(); + int count() const; + bool isEqual(const Set& set); + + Set OR(const Set& orSet) const; // return the logical OR of this set and orSet + Set AND(const Set& andSet) const; // return the logical AND of this set and andSet + + // Returns true if the intersection of the two sets is non-empty + bool intersectionIsNotEmpty(const Set& other_set) const; + + // Returns true if the intersection of the two sets is empty + bool intersectionIsEmpty(const Set& other_set) const; + + bool isSuperset(const Set& test) const; + bool isSubset(const Set& test) const { return test.isSuperset(*this); } + bool isElement(NodeID element) const; + bool isBroadcast() const; + bool isEmpty() const; + + NodeID smallestElement() const; + + // int size() const; + void setSize (int size); + + // get element for a index + NodeID elementAt(int index); + int getSize() const { return m_size; } + + // DEPRECATED METHODS + void addToSet(NodeID newElement) { add(newElement); } // Deprecated + void removeFromSet(NodeID newElement) { remove(newElement); } // Deprecated + void clearSet() { clear(); } // Deprecated + void setBroadcast() { broadcast(); } // Deprecated + bool presentInSet(NodeID element) const { return isElement(element); } // Deprecated + + void print(ostream& out) const; +private: + // Private Methods + + // Data Members (m_ prefix) + int m_size; + uint32 m_bits; // Set as a bit vector + uint32 m_mask; // a 000001111 mask where the number of 1s is equal to m_size + +}; + +// Output operator declaration +ostream& operator<<(ostream& out, const Set& obj); + +// ******************* Definitions ******************* + +// Output operator definition +extern inline +ostream& operator<<(ostream& out, const Set& obj) +{ + obj.print(out); + out << flush; + return out; +} + +#endif //SET_H +#endif //BIGSET +#endif //OPTBIGSET + -- cgit v1.2.3 From 24da30e317cdbf4b628141d69b2d17dac5ae3822 Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Mon, 11 May 2009 10:38:45 -0700 Subject: ruby: Make ruby #includes use full paths to the files they're including. This basically means changing all #include statements and changing autogenerated code so that it generates the correct paths. Because slicc generates #includes, I had to hard code the include paths to mem/protocol. --- src/mem/ruby/common/Set.hh | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'src/mem/ruby/common/Set.hh') diff --git a/src/mem/ruby/common/Set.hh b/src/mem/ruby/common/Set.hh index 7c33c840d..ea16c66a5 100644 --- a/src/mem/ruby/common/Set.hh +++ b/src/mem/ruby/common/Set.hh @@ -44,20 +44,20 @@ #define OPTBIGSET #ifdef OPTBIGSET -#include "OptBigSet.hh" +#include "mem/ruby/common/OptBigSet.hh" #else #ifdef BIGSET -#include "BigSet.hh" // code to supports sets larger than 32 +#include "mem/ruby/common/BigSet.hh" // code to supports sets larger than 32 #else #ifndef SET_H #define SET_H -#include "Global.hh" -#include "Vector.hh" -#include "NodeID.hh" -#include "RubyConfig.hh" +#include "mem/ruby/common/Global.hh" +#include "mem/gems_common/Vector.hh" +#include "mem/ruby/system/NodeID.hh" +#include "mem/ruby/config/RubyConfig.hh" class Set { public: -- cgit v1.2.3 From 7769cc9092ccfd8c6c2286762631f0d0f1f16d04 Mon Sep 17 00:00:00 2001 From: Polina Dudnik Date: Mon, 11 May 2009 10:38:46 -0700 Subject: ruby: decommission code 1. Set.* and BigSet.* are replaced with OptBigSet.* which was renamed Set.* 2. Decomissioned all bloom filters 3. Decomissioned ruby/simics directory --- src/mem/ruby/common/Set.hh | 117 ++++++++++++++++++++++++++++++++------------- 1 file changed, 85 insertions(+), 32 deletions(-) (limited to 'src/mem/ruby/common/Set.hh') diff --git a/src/mem/ruby/common/Set.hh b/src/mem/ruby/common/Set.hh index ea16c66a5..45f06e6aa 100644 --- a/src/mem/ruby/common/Set.hh +++ b/src/mem/ruby/common/Set.hh @@ -32,24 +32,15 @@ * * Description: * - * $Id$ + * $Id: BigSet.h 1.6 05/01/19 13:12:25-06:00 mikem@maya.cs.wisc.edu $ * */ -// Define this to use the BigSet class which is slower, but supports -// sets of size larger than 32. +// modified by Dan Gibson on 05/20/05 to accomidate FASTER +// >32 set lengths, using an array of ints w/ 32 bits/int -// #define BIGSET - -#define OPTBIGSET - -#ifdef OPTBIGSET -#include "mem/ruby/common/OptBigSet.hh" -#else - -#ifdef BIGSET -#include "mem/ruby/common/BigSet.hh" // code to supports sets larger than 32 -#else +// NOTE: Never include this file directly, this should only be +// included from Set.h #ifndef SET_H #define SET_H @@ -59,46 +50,95 @@ #include "mem/ruby/system/NodeID.hh" #include "mem/ruby/config/RubyConfig.hh" +// gibson 05/20/05 +// enum PresenceBit {NotPresent, Present}; + class Set { public: // Constructors // creates and empty set Set(); - Set(int size); + Set (int size); // used during the replay mechanism // Set(const char *str); - // Set(const Set& obj); - // Set& operator=(const Set& obj); + Set(const Set& obj); + Set& operator=(const Set& obj); // Destructor - // ~Set(); + ~Set(); // Public Methods - void add(NodeID newElement); + inline void add(NodeID index) + { +#ifdef __32BITS__ + m_p_nArray[index>>5] |= (1 << (index & 0x01F)); +#else + m_p_nArray[index>>6] |= (((unsigned long) 1) << (index & 0x03F)); +#endif // __32BITS__ + } + void addSet(const Set& set); void addRandom(); - void remove(NodeID newElement); + + inline void remove(NodeID index) + { +#ifdef __32BITS__ + m_p_nArray[index>>5] &= ~(0x00000001 << (index & 0x01F)); +#else + m_p_nArray[index>>6] &= ~(((unsigned long) 0x0000000000000001) << (index & 0x03F)); +#endif // __32BITS__ + } + + void removeSet(const Set& set); - void clear(); + + inline void clear() { for(int i=0; i>5] & (0x00000001 << (element & 0x01F)))!=0); +#else + return ((m_p_nArray[element>>6] & (((unsigned long) 0x0000000000000001) << (element & 0x03F)))!=0); +#endif // __32BITS__ + + } + bool isBroadcast() const; bool isEmpty() const; @@ -108,8 +148,14 @@ public: void setSize (int size); // get element for a index - NodeID elementAt(int index); - int getSize() const { return m_size; } + inline NodeID elementAt(int index) const + { + if(isElement(index)) return (NodeID) true; + else return 0; + } + + // gibson 05/20/05 + int getSize() const { return m_nSize; } // DEPRECATED METHODS void addToSet(NodeID newElement) { add(newElement); } // Deprecated @@ -123,10 +169,19 @@ private: // Private Methods // Data Members (m_ prefix) - int m_size; - uint32 m_bits; // Set as a bit vector - uint32 m_mask; // a 000001111 mask where the number of 1s is equal to m_size + // gibson 05/20/05 + // Vector m_bits; // This is an vector of uint8 to reduce the size of the set + + int m_nSize; // the number of bits in this set + int m_nArrayLen; // the number of 32-bit words that are held in the array + + // Changed 5/24/05 for static allocation of array + // note that "long" corresponds to 32 bits on a 32-bit machine, + // 64 bits if the -m64 parameter is passed to g++, which it is + // for an AMD opteron under our configuration + long * m_p_nArray; // an word array to hold the bits in the set + long m_p_nArray_Static[NUMBER_WORDS_PER_SET]; }; // Output operator declaration @@ -144,6 +199,4 @@ ostream& operator<<(ostream& out, const Set& obj) } #endif //SET_H -#endif //BIGSET -#endif //OPTBIGSET -- cgit v1.2.3