1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
|
library OSVVM ;
use OSVVM.MemorySupportPkg.all ;
use std.textio.all ;
library IEEE ;
use IEEE.std_logic_1164.all ;
use IEEE.numeric_std.all ;
use IEEE.numeric_std_unsigned.all ;
package MemoryGenericPkg is
generic (
-- type integer_vector ;
function SizeMemoryBaseType(Size : integer) return integer ; -- is <> ;
function ToMemoryBaseType (A : std_logic_vector) return integer_vector ; -- is <> ;
function FromMemoryBaseType(A : integer_vector ; Size : integer) return std_logic_vector ; -- is <> ;
function InitMemoryBaseType(Size : integer) return integer_vector -- is <>
) ;
type MemoryPType is protected
------------------------------------------------------------
impure function NewID (
Name : String ;
AddrWidth : integer ;
DataWidth : integer
) return integer ;
------------------------------------------------------------
procedure MemWrite (
ID : integer ;
Addr : std_logic_vector ;
Data : std_logic_vector
) ;
procedure MemRead (
ID : in integer ;
Addr : in std_logic_vector ;
Data : out std_logic_vector
) ;
end protected MemoryPType ;
end MemoryGenericPkg ;
package body MemoryGenericPkg is
constant BLOCK_WIDTH : integer := 10 ;
type MemoryPType is protected body
subtype MemoryBaseType is integer_vector ;
type MemBlockType is array (integer range <>) of MemoryBaseType ;
type MemBlockPtrType is access MemBlockType ;
type MemArrayType is array (integer range <>) of MemBlockPtrType ;
type MemArrayPtrType is access MemArrayType ;
type MemStructType is record
MemArrayPtr : MemArrayPtrType ;
AddrWidth : integer ;
DataWidth : natural ;
BlockWidth : natural ;
MemoryBaseTypeWidth : natural ;
end record MemStructType ;
-- New Structure
type ItemArrayType is array (integer range <>) of MemStructType ;
type ItemArrayPtrType is access ItemArrayType ;
variable Template : ItemArrayType(1 to 1) := (1 => (NULL, -1, 1, 0, 0)) ; -- Work around for QS 2020.04 and 2021.02
constant MEM_STRUCT_PTR_LEFT : integer := Template'left ;
variable MemStructPtr : ItemArrayPtrType := new ItemArrayType'(Template) ;
variable NumItems : integer := 0 ;
-- constant MIN_NUM_ITEMS : integer := 4 ; -- Temporarily small for testing
constant MIN_NUM_ITEMS : integer := 32 ; -- Min amount to resize array
------------------------------------------------------------
-- Package Local
function NormalizeArraySize( NewNumItems, MinNumItems : integer ) return integer is
------------------------------------------------------------
variable NormNumItems : integer := NewNumItems ;
variable ModNumItems : integer := 0;
begin
ModNumItems := NewNumItems mod MinNumItems ;
if ModNumItems > 0 then
NormNumItems := NormNumItems + (MinNumItems - ModNumItems) ;
end if ;
return NormNumItems ;
end function NormalizeArraySize ;
------------------------------------------------------------
-- Package Local
procedure GrowNumberItems (
------------------------------------------------------------
variable ItemArrayPtr : InOut ItemArrayPtrType ;
variable NumItems : InOut integer ;
constant GrowAmount : in integer ;
-- constant NewNumItems : in integer ;
-- constant CurNumItems : in integer ;
constant MinNumItems : in integer
) is
variable oldItemArrayPtr : ItemArrayPtrType ;
variable NewNumItems : integer ;
begin
NewNumItems := NumItems + GrowAmount ;
-- Array Allocated in declaration to have a single item, but no items (historical mode)
-- if ItemArrayPtr = NULL then
-- ItemArrayPtr := new ItemArrayType(1 to NormalizeArraySize(NewNumItems, MinNumItems)) ;
-- elsif NewNumItems > ItemArrayPtr'length then
if NewNumItems > ItemArrayPtr'length then
oldItemArrayPtr := ItemArrayPtr ;
ItemArrayPtr := new ItemArrayType(1 to NormalizeArraySize(NewNumItems, MinNumItems)) ;
ItemArrayPtr.all(1 to NumItems) := oldItemArrayPtr.all(1 to NumItems) ;
deallocate(oldItemArrayPtr) ;
end if ;
NumItems := NewNumItems ;
end procedure GrowNumberItems ;
------------------------------------------------------------
-- PT Local
procedure MemInit (ID : integer ; AddrWidth, DataWidth : integer ) is
------------------------------------------------------------
constant ADJ_BLOCK_WIDTH : integer := minimum(BLOCK_WIDTH, AddrWidth) ;
begin
if AddrWidth <= 0 then
return ;
end if ;
-- if DataWidth <= 0 or DataWidth > 31 then
-- Alert(MemStructPtr(ID).AlertLogID, "MemoryPkg.MemInit/NewID. DataWidth = " & to_string(DataWidth) & " must be > 0 and <= 31.", FAILURE) ;
if DataWidth <= 0 then
return ;
end if ;
MemStructPtr(ID).AddrWidth := AddrWidth ;
MemStructPtr(ID).DataWidth := DataWidth ;
MemStructPtr(ID).MemoryBaseTypeWidth := SizeMemoryBaseType(DataWidth) ;
MemStructPtr(ID).BlockWidth := ADJ_BLOCK_WIDTH ;
MemStructPtr(ID).MemArrayPtr := new MemArrayType(0 to 2**(AddrWidth-ADJ_BLOCK_WIDTH)-1) ;
end procedure MemInit ;
------------------------------------------------------------
impure function NewID (
------------------------------------------------------------
Name : String ;
AddrWidth : integer ;
DataWidth : integer
) return integer is
variable NameID : integer ;
begin
-- Add New Memory to Structure
GrowNumberItems(MemStructPtr, NumItems, GrowAmount => 1, MinNumItems => MIN_NUM_ITEMS) ;
-- Construct Memory, Reports agains AlertLogID
MemInit(NumItems, AddrWidth, DataWidth) ;
-- Check NameStore Index vs MemoryIndex
return NumItems ;
end function NewID ;
------------------------------------------------------------
-- PT Local
impure function IdOutOfRange(
------------------------------------------------------------
constant ID : in integer ;
constant Name : in string
) return boolean is
begin
return ID < MemStructPtr'Low or ID > MemStructPtr'High;
end function IdOutOfRange ;
------------------------------------------------------------
procedure MemWrite (
------------------------------------------------------------
ID : integer ;
Addr : std_logic_vector ;
Data : std_logic_vector
) is
variable BlockWidth : integer ;
variable MemoryBaseTypeWidth : integer ;
-- constant BlockWidth : integer := MemStructPtr(ID).BlockWidth;
variable BlockAddr, WordAddr : integer ;
alias aAddr : std_logic_vector (Addr'length-1 downto 0) is Addr ;
-- subtype MemBlockSubType is MemBlockType(0 to 2**BlockWidth-1) ;
begin
if IdOutOfRange(ID, "MemWrite") then
return ;
end if ;
BlockWidth := MemStructPtr(ID).BlockWidth ;
MemoryBaseTypeWidth := MemStructPtr(ID).MemoryBaseTypeWidth ;
-- Check Bounds of Address and if memory is initialized
if Addr'length /= MemStructPtr(ID).AddrWidth then
return ;
end if ;
-- Check Bounds on Data
if Data'length /= MemStructPtr(ID).DataWidth then
return ;
end if ;
if is_X( Addr ) then
return ;
end if ;
-- Slice out upper address to form block address
if aAddr'high >= BlockWidth then
BlockAddr := to_integer(aAddr(aAddr'high downto BlockWidth)) ;
else
BlockAddr := 0 ;
end if ;
-- If empty, allocate a memory block
if (MemStructPtr(ID).MemArrayPtr(BlockAddr) = NULL) then
-- MemStructPtr(ID).MemArrayPtr(BlockAddr) := new MemBlockType'(0 to 2**BlockWidth-1 => InitMemoryBaseType(Data'length)) ;
MemStructPtr(ID).MemArrayPtr(BlockAddr) := new MemBlockType(0 to 2**BlockWidth-1)(MemoryBaseTypeWidth downto 1) ; -- => InitMemoryBaseType(Data'length)) ;
MemStructPtr(ID).MemArrayPtr(BlockAddr)(0 to 2**BlockWidth-1) := (0 to 2**BlockWidth-1 => InitMemoryBaseType(Data'length)) ;
--KO2 MemStructPtr(ID).MemArrayPtr(BlockAddr)(0 to 2**BlockWidth-1) := (others => InitMemoryBaseType(Data'length)) ;
end if ;
-- Address of a word within a block
WordAddr := to_integer(aAddr(BlockWidth -1 downto 0)) ;
-- Write to BlockAddr, WordAddr
MemStructPtr(ID).MemArrayPtr(BlockAddr)(WordAddr) := ToMemoryBaseType(Data) ;
end procedure MemWrite ;
------------------------------------------------------------
procedure MemRead (
------------------------------------------------------------
ID : in integer ;
Addr : in std_logic_vector ;
Data : out std_logic_vector
) is
variable BlockWidth : integer ;
variable BlockAddr, WordAddr : integer ;
alias aAddr : std_logic_vector (Addr'length-1 downto 0) is Addr ;
begin
if IdOutOfRange(ID, "MemRead") then
return ;
end if ;
BlockWidth := MemStructPtr(ID).BlockWidth ;
-- Check Bounds of Address and if memory is initialized
if Addr'length /= MemStructPtr(ID).AddrWidth then
Data := (Data'range => 'U') ;
return ;
end if ;
-- Check Bounds on Data
if Data'length /= MemStructPtr(ID).DataWidth then
Data := (Data'range => 'U') ;
return ;
end if ;
-- If Addr X, data = X
if is_X( aAddr ) then
Data := (Data'range => 'X') ;
return ;
end if ;
-- Slice out upper address to form block address
if aAddr'high >= BlockWidth then
BlockAddr := to_integer(aAddr(aAddr'high downto BlockWidth)) ;
else
BlockAddr := 0 ;
end if ;
-- Empty Block, return all U
if (MemStructPtr(ID).MemArrayPtr(BlockAddr) = NULL) then
Data := (Data'range => 'U') ;
return ;
end if ;
-- Address of a word within a block
WordAddr := to_integer(aAddr(BlockWidth -1 downto 0)) ;
Data := FromMemoryBaseType(MemStructPtr(ID).MemArrayPtr(BlockAddr)(WordAddr), Data'length) ;
end procedure MemRead ;
end protected body MemoryPType ;
end MemoryGenericPkg ;
library OSVVM ;
use OSVVM.MemorySupportPkg.all ;
package MemoryPkg is new work.MemoryGenericPkg
generic map (
-- MemoryBaseType => MemoryBaseType_X,
SizeMemoryBaseType => SizeMemoryBaseType_X,
ToMemoryBaseType => ToMemoryBaseType_X,
FromMemoryBaseType => FromMemoryBaseType_X,
InitMemoryBaseType => InitMemoryBaseType_X
) ;
library ieee ;
use ieee.std_logic_1164.all ;
use ieee.numeric_std.all ;
use work.MemoryPkg.all;
entity tb3 is
end;
architecture behav of tb3 is
shared variable MemoryStore : MemoryPType ;
begin
process
variable MemoryID : integer;
begin
MemoryID := MemoryStore.NewID(
Name => "my_sram",
AddrWidth => 20,
DataWidth => 16);
MemoryStore.MemWrite(MemoryId, x"00000", x"0000");
wait;
end process;
end ;
|
