1# Copyright (c) 2018 ARM Limited
2# All rights reserved.
3#
4# The license below extends only to copyright in the software and shall
5# not be construed as granting a license to any other intellectual
6# property including but not limited to intellectual property relating
7# to a hardware implementation of the functionality of the software
8# licensed hereunder. You may use the software subject to the license
9# terms below provided that you ensure that this notice is replicated
10# unmodified and in its entirety in all distributions of the software,
11# modified or unmodified, in source code or in binary form.
12#
13# Copyright (c) 2004-2006 The Regents of The University of Michigan
14# All rights reserved.
15#
16# Redistribution and use in source and binary forms, with or without
17# modification, are permitted provided that the following conditions are
18# met: redistributions of source code must retain the above copyright
19# notice, this list of conditions and the following disclaimer;
20# redistributions in binary form must reproduce the above copyright
21# notice, this list of conditions and the following disclaimer in the
22# documentation and/or other materials provided with the distribution;
23# neither the name of the copyright holders nor the names of its
24# contributors may be used to endorse or promote products derived from
25# this software without specific prior written permission.
26#
27# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
30# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
31# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
32# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
33# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
34# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
35# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
36# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
37# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38#
39# Authors: Steve Reinhardt
40# Nathan Binkert
41
42#####################################################################
43#
44# Proxy object support.
45#
46#####################################################################
47
48from __future__ import print_function
49from __future__ import absolute_import
|
53
54import copy
55
56
57class BaseProxy(object):
58 def __init__(self, search_self, search_up):
59 self._search_self = search_self
60 self._search_up = search_up
61 self._multipliers = []
62
63 def __str__(self):
64 if self._search_self and not self._search_up:
65 s = 'Self'
66 elif not self._search_self and self._search_up:
67 s = 'Parent'
68 else:
69 s = 'ConfusedProxy'
70 return s + '.' + self.path()
71
72 def __setattr__(self, attr, value):
73 if not attr.startswith('_'):
74 raise AttributeError(
75 "cannot set attribute '%s' on proxy object" % attr)
76 super(BaseProxy, self).__setattr__(attr, value)
77
78 # support for multiplying proxies by constants or other proxies to
79 # other params
80 def __mul__(self, other):
81 if not (isinstance(other, (int, long, float)) or isproxy(other)):
82 raise TypeError(
83 "Proxy multiplier must be a constant or a proxy to a param")
84 self._multipliers.append(other)
85 return self
86
87 __rmul__ = __mul__
88
89 def _mulcheck(self, result, base):
90 for multiplier in self._multipliers:
91 if isproxy(multiplier):
92 multiplier = multiplier.unproxy(base)
93 # assert that we are multiplying with a compatible
94 # param
95 if not isinstance(multiplier, params.NumericParamValue):
96 raise TypeError(
97 "Proxy multiplier must be a numerical param")
98 multiplier = multiplier.getValue()
99 result *= multiplier
100 return result
101
102 def unproxy(self, base):
103 obj = base
104 done = False
105
106 if self._search_self:
107 result, done = self.find(obj)
108
109 if self._search_up:
110 # Search up the tree but mark ourself
111 # as visited to avoid a self-reference
112 self._visited = True
113 obj._visited = True
114 while not done:
115 obj = obj._parent
116 if not obj:
117 break
118 result, done = self.find(obj)
119
120 self._visited = False
121 base._visited = False
122
123 if not done:
124 raise AttributeError(
125 "Can't resolve proxy '%s' of type '%s' from '%s'" % \
126 (self.path(), self._pdesc.ptype_str, base.path()))
127
128 if isinstance(result, BaseProxy):
129 if result == self:
130 raise RuntimeError("Cycle in unproxy")
131 result = result.unproxy(obj)
132
133 return self._mulcheck(result, base)
134
135 def getindex(obj, index):
136 if index == None:
137 return obj
138 try:
139 obj = obj[index]
140 except TypeError:
141 if index != 0:
142 raise
143 # if index is 0 and item is not subscriptable, just
144 # use item itself (so cpu[0] works on uniprocessors)
145 return obj
146 getindex = staticmethod(getindex)
147
148 # This method should be called once the proxy is assigned to a
149 # particular parameter or port to set the expected type of the
150 # resolved proxy
151 def set_param_desc(self, pdesc):
152 self._pdesc = pdesc
153
154class AttrProxy(BaseProxy):
155 def __init__(self, search_self, search_up, attr):
156 super(AttrProxy, self).__init__(search_self, search_up)
157 self._attr = attr
158 self._modifiers = []
159
160 def __getattr__(self, attr):
161 # python uses __bases__ internally for inheritance
162 if attr.startswith('_'):
163 return super(AttrProxy, self).__getattr__(self, attr)
164 if hasattr(self, '_pdesc'):
165 raise AttributeError("Attribute reference on bound proxy")
166 # Return a copy of self rather than modifying self in place
167 # since self could be an indirect reference via a variable or
168 # parameter
169 new_self = copy.deepcopy(self)
170 new_self._modifiers.append(attr)
171 return new_self
172
173 # support indexing on proxies (e.g., Self.cpu[0])
174 def __getitem__(self, key):
175 if not isinstance(key, int):
176 raise TypeError("Proxy object requires integer index")
177 if hasattr(self, '_pdesc'):
178 raise AttributeError("Index operation on bound proxy")
179 new_self = copy.deepcopy(self)
180 new_self._modifiers.append(key)
181 return new_self
182
183 def find(self, obj):
184 try:
185 val = getattr(obj, self._attr)
186 visited = False
187 if hasattr(val, '_visited'):
188 visited = getattr(val, '_visited')
189
190 if not visited:
191 # for any additional unproxying to be done, pass the
192 # current, rather than the original object so that proxy
193 # has the right context
194 obj = val
195 else:
196 return None, False
197 except:
198 return None, False
199 while isproxy(val):
200 val = val.unproxy(obj)
201 for m in self._modifiers:
202 if isinstance(m, str):
203 val = getattr(val, m)
204 elif isinstance(m, int):
205 val = val[m]
206 else:
207 assert("Item must be string or integer")
208 while isproxy(val):
209 val = val.unproxy(obj)
210 return val, True
211
212 def path(self):
213 p = self._attr
214 for m in self._modifiers:
215 if isinstance(m, str):
216 p += '.%s' % m
217 elif isinstance(m, int):
218 p += '[%d]' % m
219 else:
220 assert("Item must be string or integer")
221 return p
222
223class AnyProxy(BaseProxy):
224 def find(self, obj):
225 return obj.find_any(self._pdesc.ptype)
226
227 def path(self):
228 return 'any'
229
230# The AllProxy traverses the entire sub-tree (not only the children)
231# and adds all objects of a specific type
232class AllProxy(BaseProxy):
233 def find(self, obj):
234 return obj.find_all(self._pdesc.ptype)
235
236 def path(self):
237 return 'all'
238
239def isproxy(obj):
240 from . import params
241 if isinstance(obj, (BaseProxy, params.EthernetAddr)):
242 return True
243 elif isinstance(obj, (list, tuple)):
244 for v in obj:
245 if isproxy(v):
246 return True
247 return False
248
249class ProxyFactory(object):
250 def __init__(self, search_self, search_up):
251 self.search_self = search_self
252 self.search_up = search_up
253
254 def __getattr__(self, attr):
255 if attr == 'any':
256 return AnyProxy(self.search_self, self.search_up)
257 elif attr == 'all':
258 if self.search_up:
259 assert("Parant.all is not supported")
260 return AllProxy(self.search_self, self.search_up)
261 else:
262 return AttrProxy(self.search_self, self.search_up, attr)
263
264# global objects for handling proxies
265Parent = ProxyFactory(search_self = False, search_up = True)
266Self = ProxyFactory(search_self = True, search_up = False)
267
268# limit exports on 'from proxy import *'
269__all__ = ['Parent', 'Self']
|