summaryrefslogtreecommitdiff
path: root/src/systemc/ext/dt/sc_temporary.hh
diff options
context:
space:
mode:
authorGabe Black <gabeblack@google.com>2018-05-22 02:21:17 -0700
committerGabe Black <gabeblack@google.com>2018-08-08 10:08:12 +0000
commit5ee040a534d422ee08918ef49d55620184df7120 (patch)
tree1688e050dec6abf1a36fc92070b151e6b0682fdd /src/systemc/ext/dt/sc_temporary.hh
parent7adb1b250b712920ea5d685f146ad6df55346393 (diff)
downloadgem5-5ee040a534d422ee08918ef49d55620184df7120.tar.xz
Systemc: Port over all of the systemc "datatype" headers.
These are the headers originally written by Accellera with a few modifications. Most significantly, I went through and mostly (but not entirely) manually editted them to conform to gem5 style and to be more self consistent. Second, I resolved some macros which optionally select features. I removed support for deprecated functions, and otherwise enabled everything. The actual implementation behind these headers will also be ported over, but in a subsequent change. Change-Id: I203d3f6c8a3af9120b946001d01defbb0643a6b6 Reviewed-on: https://gem5-review.googlesource.com/10843 Reviewed-by: Gabe Black <gabeblack@google.com> Maintainer: Gabe Black <gabeblack@google.com>
Diffstat (limited to 'src/systemc/ext/dt/sc_temporary.hh')
-rw-r--r--src/systemc/ext/dt/sc_temporary.hh227
1 files changed, 227 insertions, 0 deletions
diff --git a/src/systemc/ext/dt/sc_temporary.hh b/src/systemc/ext/dt/sc_temporary.hh
new file mode 100644
index 000000000..c462b7fe0
--- /dev/null
+++ b/src/systemc/ext/dt/sc_temporary.hh
@@ -0,0 +1,227 @@
+/*****************************************************************************
+
+ Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
+ more contributor license agreements. See the NOTICE file distributed
+ with this work for additional information regarding copyright ownership.
+ Accellera licenses this file to you under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with the
+ License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ permissions and limitations under the License.
+
+ *****************************************************************************/
+
+/*****************************************************************************
+
+ sc_temporary.h -- Temporary value pool classes.
+
+ Original Author: Andy Goodrich, Forte Design Systems, Inc.
+
+ CHANGE LOG AT END OF FILE
+ *****************************************************************************/
+
+#ifndef __SYSTEMC_EXT_DT_SC_TEMPORARY_HH__
+#define __SYSTEMC_EXT_DT_SC_TEMPORARY_HH__
+
+#include <cstddef> // std::size_t
+
+namespace sc_core
+{
+
+//-----------------------------------------------------------------------------
+// sc_byte_heap - CLASS MANAGING A TEMPORARY HEAP OF BYTES
+//
+// This facility implements a heap of temporary byte allocations. Once an
+// request has been allocated it is not freed. However the entire heap
+// wraps and the storage is reused. This means that no allocations should
+// be assumed as permanent. Allocations are double-word aligned. This is
+// raw storage, so objects which contain virtual methods cannot be allocated
+// with this object. See the sc_vpool object for that type of storage
+// allocation.
+//
+// char* allocate( int size )
+// This method returns a pointer to block of size bytes. The block
+// returned is the next available one in the heap. If the current heap
+// cannot fullfil the request it will be rewound and storage allocated from
+// its start. All allocations start on an 8-byte boundary.
+// size = number of bytes to be allocated.
+//
+// void initialize( int heap_size=0x100000 )
+// This method allocates the storage to be managed. If there is already
+// a block of storage under management it is freed. If no argument is
+// provided for the heap size, a megabyte will be allocated.
+// heap_size = number of bytes to allocate for the heap.
+//
+// unsigned int length()
+// This method returns the size of this object's heap in bytes.
+//
+// sc_byte_heap()
+// This is the non-initialized object instance constructor. It does not
+// allocate the heap storage, that is done by the initialize() method.
+//
+// sc_byte_heap(int)
+// This is the initializing object instance constructor. It does allocates
+// a heap of the specified number of bytes.
+// heap_size = number of bytes to allocate for the heap.
+//-----------------------------------------------------------------------------
+class sc_byte_heap
+{
+ public:
+ char *m_bgn_p; // Beginning of heap storage.
+ char *m_end_p; // End of heap storage.
+ char *m_next_p; // Next heap location to be allocated.
+
+ inline char *
+ allocate(std::size_t bytes_n)
+ {
+ char *result_p;
+ bytes_n = (bytes_n + 7) & ((std::size_t)(-8));
+ result_p = m_next_p;
+ m_next_p += bytes_n;
+ if (m_next_p >= m_end_p) {
+ result_p = m_bgn_p;
+ m_next_p = m_bgn_p + bytes_n;
+ }
+ return result_p;
+ }
+
+ inline void
+ initialize(std::size_t heap_size=0x100000)
+ {
+ delete [] m_bgn_p;
+ m_bgn_p = new char[heap_size];
+ m_end_p = &m_bgn_p[heap_size];
+ m_next_p = m_bgn_p;
+ }
+
+ inline std::size_t
+ length()
+ {
+ return (std::size_t)(m_end_p - m_bgn_p);
+ }
+
+ inline sc_byte_heap() : m_bgn_p(0), m_end_p(0), m_next_p(0) {}
+
+ inline sc_byte_heap(std::size_t heap_size) :
+ m_bgn_p(0), m_end_p(0), m_next_p(0)
+ {
+ initialize(heap_size);
+ }
+
+ inline ~sc_byte_heap() { delete [] m_bgn_p; }
+};
+
+
+//-----------------------------------------------------------------------------
+// sc_vpool<T> - CLASS MANAGING A TEMPORARY VECTOR OF CLASS T INSTANCES
+//
+// This class implements a fixed pool of objects contained in a vector. These
+// objects are allocated via the allocate() method. An index, m_pool_i,
+// indicates the next object to be allocated. The vector is a power of 2 in
+// size, and this fact is used to wrap the list when m_pool_i reaches the
+// end of the vector.
+//
+// sc_vpool( int log2, T* pool_p=0 )
+// This is the object instance constructor for this class. It configures
+// the object to manage a vector of 2**log2 entries. If a vector is
+// not supplied one will be allocated.
+// log2 = the log base two of the size of the vector.
+// pool_p -> vector of 2**log2 entries to be managed or 0.
+//
+// ~sc_vpool()
+// This is the object instance destructor for this class. It frees the
+// block of storage which was being managed.
+//
+// T* allocate()
+// This method returns the address of the next entry in the vector, m_pool_p,
+// pointed to by the index, m_pool_i, and updates that index. The index
+// update consists of adding 1 to m_pool_i and masking it by m_wrap.
+//
+// void reset()
+// This method resets the allocation index, m_pool_i, to point to the start
+// of the vector of objects under management. This call is not usually made
+// since there are a fixed number of entries and the index wraps. However,
+// for diagnostics tests it is convenient to be able to reset to the start
+// of the vector.
+//
+// int size()
+// This method returns the number of object instances contained in the
+// vector being managed by this object instance.
+//-----------------------------------------------------------------------------
+template<class T>
+class sc_vpool
+{
+ protected:
+ std::size_t m_pool_i; // Index of next entry to m_pool_m to provide.
+ T *m_pool_p; // Vector of temporaries.
+ std::size_t m_wrap; // Mask to wrap vector index.
+
+ public:
+ inline sc_vpool(int log2, T *pool_p=0);
+ inline ~sc_vpool();
+ inline T *allocate();
+ inline void reset();
+ inline std::size_t size();
+};
+
+template<class T>
+sc_vpool<T>::sc_vpool(int log2, T *pool_p) : m_pool_i(0),
+ m_pool_p(pool_p ? pool_p : new T[static_cast<std::size_t>(1) << log2]),
+ m_wrap(~(static_cast<std::size_t>(-1) << log2))
+{
+ // if (log2 > 32) SC_REPORT_ERROR(SC_ID_POOL_SIZE_, "");
+}
+
+template<class T>
+sc_vpool<T>::~sc_vpool()
+{
+ // delete [] m_pool_p;
+}
+
+template<class T>
+T *sc_vpool<T>::allocate()
+{
+ T *result_p; // Entry to return.
+
+ result_p = &m_pool_p[m_pool_i];
+ m_pool_i = (m_pool_i + 1) & m_wrap;
+ return result_p;
+}
+
+template<class T>
+void sc_vpool<T>::reset()
+{
+ m_pool_i = 0;
+}
+
+template<class T>
+std::size_t sc_vpool<T>::size() { return m_wrap + 1; }
+
+} // namespace sc_core
+
+// $Log: sc_temporary.h,v $
+// Revision 1.4 2011/08/26 20:46:19 acg
+// Andy Goodrich: moved the modification log to the end of the file to
+// eliminate source line number skew when check-ins are done.
+//
+// Revision 1.3 2011/08/24 22:05:56 acg
+// Torsten Maehne: initialization changes to remove warnings.
+//
+// Revision 1.2 2011/02/18 20:38:44 acg
+// Andy Goodrich: Updated Copyright notice.
+//
+// Revision 1.1.1.1 2006/12/15 20:20:06 acg
+// SystemC 2.3
+//
+// Revision 1.3 2006/01/13 18:53:11 acg
+// Andy Goodrich: Added $Log command so that CVS comments are reproduced in
+// the source.
+//
+
+#endif // __SYSTEMC_EXT_DT_SC_TEMPORARY_HH__