1/*
2 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
| 1/*
2 * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
|
| 3 * Copyright (c) 2013 Advanced Micro Devices, Inc.
|
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/*
30 * These are the functions that exported to slicc from ruby.
31 */
32
33#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
34#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
35
36#include <cassert>
37
38#include "debug/RubySlicc.hh"
39#include "mem/packet.hh"
40#include "mem/ruby/common/Address.hh"
41#include "mem/ruby/common/BoolVec.hh"
42#include "mem/ruby/common/DataBlock.hh"
43#include "mem/ruby/common/TypeDefines.hh"
| 4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer;
10 * redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution;
13 * neither the name of the copyright holders nor the names of its
14 * contributors may be used to endorse or promote products derived from
15 * this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/*
31 * These are the functions that exported to slicc from ruby.
32 */
33
34#ifndef __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
35#define __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
36
37#include <cassert>
38
39#include "debug/RubySlicc.hh"
40#include "mem/packet.hh"
41#include "mem/ruby/common/Address.hh"
42#include "mem/ruby/common/BoolVec.hh"
43#include "mem/ruby/common/DataBlock.hh"
44#include "mem/ruby/common/TypeDefines.hh"
|
| 45#include "mem/ruby/common/WriteMask.hh"
|
44
45inline Cycles zero_time() { return Cycles(0); }
46
47inline NodeID
48intToID(int nodenum)
49{
50 NodeID id = nodenum;
51 return id;
52}
53
54inline int
55IDToInt(NodeID id)
56{
57 int nodenum = id;
58 return nodenum;
59}
60
61inline int
62addressToInt(Addr addr)
63{
64 assert(!(addr & 0xffffffff00000000));
65 return addr;
66}
67
68inline Addr
69intToAddress(int addr)
70{
71 assert(!(addr & 0xffffffff00000000));
72 return addr;
73}
74
75inline int
76mod(int val, int mod)
77{
78 return val % mod;
79}
80
81inline int max_tokens()
82{
83 return 1024;
84}
85
86/**
87 * This function accepts an address, a data block and a packet. If the address
88 * range for the data block contains the address which the packet needs to
89 * read, then the data from the data block is written to the packet. True is
90 * returned if the data block was read, otherwise false is returned.
| 46
47inline Cycles zero_time() { return Cycles(0); }
48
49inline NodeID
50intToID(int nodenum)
51{
52 NodeID id = nodenum;
53 return id;
54}
55
56inline int
57IDToInt(NodeID id)
58{
59 int nodenum = id;
60 return nodenum;
61}
62
63inline int
64addressToInt(Addr addr)
65{
66 assert(!(addr & 0xffffffff00000000));
67 return addr;
68}
69
70inline Addr
71intToAddress(int addr)
72{
73 assert(!(addr & 0xffffffff00000000));
74 return addr;
75}
76
77inline int
78mod(int val, int mod)
79{
80 return val % mod;
81}
82
83inline int max_tokens()
84{
85 return 1024;
86}
87
88/**
89 * This function accepts an address, a data block and a packet. If the address
90 * range for the data block contains the address which the packet needs to
91 * read, then the data from the data block is written to the packet. True is
92 * returned if the data block was read, otherwise false is returned.
|
| 93 *
94 * This is used during a functional access "search the world" operation. The
95 * functional access looks in every place that might hold a valid data block
96 * and, if it finds one, checks to see if it is holding the address the access
97 * is searching for. During the access check, the WriteMask could be in any
98 * state, including empty.
|
91 */
92inline bool
93testAndRead(Addr addr, DataBlock& blk, Packet *pkt)
94{
95 Addr pktLineAddr = makeLineAddress(pkt->getAddr());
96 Addr lineAddr = makeLineAddress(addr);
97
98 if (pktLineAddr == lineAddr) {
99 uint8_t *data = pkt->getPtr<uint8_t>();
100 unsigned int size_in_bytes = pkt->getSize();
101 unsigned startByte = pkt->getAddr() - lineAddr;
102
103 for (unsigned i = 0; i < size_in_bytes; ++i) {
104 data[i] = blk.getByte(i + startByte);
105 }
106 return true;
107 }
108 return false;
109}
110
111/**
| 99 */
100inline bool
101testAndRead(Addr addr, DataBlock& blk, Packet *pkt)
102{
103 Addr pktLineAddr = makeLineAddress(pkt->getAddr());
104 Addr lineAddr = makeLineAddress(addr);
105
106 if (pktLineAddr == lineAddr) {
107 uint8_t *data = pkt->getPtr<uint8_t>();
108 unsigned int size_in_bytes = pkt->getSize();
109 unsigned startByte = pkt->getAddr() - lineAddr;
110
111 for (unsigned i = 0; i < size_in_bytes; ++i) {
112 data[i] = blk.getByte(i + startByte);
113 }
114 return true;
115 }
116 return false;
117}
118
119/**
|
| 120 * This function accepts an address, a data block, a write mask and a packet.
121 * If the valid address range for the data block contains the address which
122 * the packet needs to read, then the data from the data block is written to
123 * the packet. True is returned if any part of the data block was read,
124 * otherwise false is returned.
125 */
126inline bool
127testAndReadMask(Addr addr, DataBlock& blk, WriteMask& mask, Packet *pkt)
128{
129 Addr pktLineAddr = makeLineAddress(pkt->getAddr());
130 Addr lineAddr = makeLineAddress(addr);
131
132 if (pktLineAddr == lineAddr) {
133 uint8_t *data = pkt->getPtr<uint8_t>();
134 unsigned int size_in_bytes = pkt->getSize();
135 unsigned startByte = pkt->getAddr() - lineAddr;
136 bool was_read = false;
137
138 for (unsigned i = 0; i < size_in_bytes; ++i) {
139 if (mask.test(i + startByte)) {
140 was_read = true;
141 data[i] = blk.getByte(i + startByte);
142 }
143 }
144 return was_read;
145 }
146 return false;
147}
148
149/**
|
112 * This function accepts an address, a data block and a packet. If the address
113 * range for the data block contains the address which the packet needs to
114 * write, then the data from the packet is written to the data block. True is
115 * returned if the data block was written, otherwise false is returned.
116 */
117inline bool
118testAndWrite(Addr addr, DataBlock& blk, Packet *pkt)
119{
120 Addr pktLineAddr = makeLineAddress(pkt->getAddr());
121 Addr lineAddr = makeLineAddress(addr);
122
123 if (pktLineAddr == lineAddr) {
124 const uint8_t *data = pkt->getConstPtr<uint8_t>();
125 unsigned int size_in_bytes = pkt->getSize();
126 unsigned startByte = pkt->getAddr() - lineAddr;
127
128 for (unsigned i = 0; i < size_in_bytes; ++i) {
129 blk.setByte(i + startByte, data[i]);
130 }
131 return true;
132 }
133 return false;
134}
135
136inline int
137countBoolVec(BoolVec bVec)
138{
139 int count = 0;
140 for (const auto &it: bVec) {
141 if (it) {
142 count++;
143 }
144 }
145 return count;
146}
147
148#endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
| 150 * This function accepts an address, a data block and a packet. If the address
151 * range for the data block contains the address which the packet needs to
152 * write, then the data from the packet is written to the data block. True is
153 * returned if the data block was written, otherwise false is returned.
154 */
155inline bool
156testAndWrite(Addr addr, DataBlock& blk, Packet *pkt)
157{
158 Addr pktLineAddr = makeLineAddress(pkt->getAddr());
159 Addr lineAddr = makeLineAddress(addr);
160
161 if (pktLineAddr == lineAddr) {
162 const uint8_t *data = pkt->getConstPtr<uint8_t>();
163 unsigned int size_in_bytes = pkt->getSize();
164 unsigned startByte = pkt->getAddr() - lineAddr;
165
166 for (unsigned i = 0; i < size_in_bytes; ++i) {
167 blk.setByte(i + startByte, data[i]);
168 }
169 return true;
170 }
171 return false;
172}
173
174inline int
175countBoolVec(BoolVec bVec)
176{
177 int count = 0;
178 for (const auto &it: bVec) {
179 if (it) {
180 count++;
181 }
182 }
183 return count;
184}
185
186#endif // __MEM_RUBY_SLICC_INTERFACE_RUBYSLICCUTIL_HH__
|