source: branches/RWT/communication/dspin_dhccp_param/caba/source/include/dspin_dhccp_param.h @ 604

Last change on this file since 604 was 604, checked in by devigne, 9 years ago

Merge with the latest trunk (concurrent access to a register CONFIG_FSM)
Modification processing software invalidations to memcache level.

When a software memcache invalidation, it does not write the dirty data in the
XRAM (and therefore does not reserve space in the TRT). This poses a problem
when processing CLEANUP_DATA on a line NCC because CLEANUP_FSM expects to find
a placeholder in the TRT.

To overcome this problem, the flit DSPIN a multi-inval now contains a bit to
indicate that the invalidation from a control configuration (software
invalidation level memcache).

At the reception of this message invalidation in the L1 cache, it retrieves the
value of the field DSPIN IS_CONFIG. When processing invalidation (
DCACHE_CC_INVAL ), the value of this field is checked. Two scenarios are
possible:

  • 1st case : The INVAL concerns a line NCC but not from a software invalidation (IS_CONFIG = 0), the CLEANUP sent then follows the classical treatment of invalidation of a line NCC (sends a CLEANUP_NCC with or without data).
  • 2nd case : The INVAL provides a line NCC from a software invalidation (IS_CONFIG = 1) : same treatment as was CLEANUP line CC.

Thus in the case of interest (software invalidation on a line NCC), the CLEANUP
received by the memcache will be treated as one line CC.

File size: 17.4 KB
Line 
1/* -*- c++ -*-
2 * File         : dspin_dhccp_param.h
3 * Date         : 01/03/2013
4 * Copyright    : UPMC / LIP6
5 * Authors      : Cesar Fuguet
6 *
7 * SOCLIB_LGPL_HEADER_BEGIN
8 *
9 * This file is part of SoCLib, GNU LGPLv2.1.
10 *
11 * SoCLib is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published
13 * by the Free Software Foundation; version 2.1 of the License.
14 *
15 * SoCLib is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with SoCLib; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
23 * 02110-1301 USA
24 *
25 * SOCLIB_LGPL_HEADER_END
26 */
27
28
29#ifndef DSPIN_DHCCP_PARAMS_H
30#define DSPIN_DHCCP_PARAMS_H
31
32#include <inttypes.h>
33#include <assert.h>
34
35namespace soclib { namespace caba {
36
37/*
38 * L1 cache to Memory Cache command packets
39 *
40 * CLEANUP
41 *
42 * flit 1
43 * --------------------------------------------------------------------------------------------------------
44 * EOP:0 |    DEST    |   SRCID   | NLINE MSB(2 bits)| CONTAINS_DATA | WAY_INDEX(2 bits) | TYPE:0b1X | BC:0
45 *       |  (10 bits) | (14 bits) |                  |               |                   |           |
46 * --------------------------------------------------------------------------------------------------------
47 *                                                                                 | X: 0 DATA  |
48 *                                                                                 |    1 INST  |
49 * flit 2
50 * ----------------------------------------------------------------------------------------------
51 * EOP:0/1 |                                                                       NLINE(32 bits)
52 * ----------------------------------------------------------------------------------------------
53 *
54 * flit N for data
55 * ----------------------------------------------------------------------------------------------
56 * EOP:0/1 |                                                                       WDATA(32 bits)
57 * ----------------------------------------------------------------------------------------------
58 *
59 * MULTICAST ACKNOWLEDGEMENT
60 *
61 * flit 1
62 * ----------------------------------------------------------------------------------------------
63 * EOP:1 |     DEST(10 bits)     |       X(15 bits)       | UPDT_INDEX(4 bits) | TYPE:0b00 | BC:0
64 * ----------------------------------------------------------------------------------------------
65 */
66
67/*
68 * M2P command packets
69 *
70 * MULTICAST UPDATE
71 *
72 * flit 1
73 * ----------------------------------------------------------------------------------------------
74 * EOP:0 | DEST(14 bits) | X(4 bits) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b0X   | BC:0
75 * ----------------------------------------------------------------------------------------------
76 *                                                                           | X: 0 DATA   |
77 *                                                                           |    1 INST   |
78 * flit 2
79 * ----------------------------------------------------------------------------------------------
80 * EOP:0 | X | WORD_INDEX(4 bits)  |                                             NLINE (34 bits)
81 * ----------------------------------------------------------------------------------------------
82 *
83 * flit 3
84 * ----------------------------------------------------------------------------------------------
85 * EOP:0 | X(3 bits)  | BE(4 bits) |                                              WDATA(32 bits)
86 * ----------------------------------------------------------------------------------------------
87 *
88 * flit N
89 * ----------------------------------------------------------------------------------------------
90 * EOP:1 | X(3 bits)  | BE(4 bits) |                                              WDATA(32 bits)
91 * ----------------------------------------------------------------------------------------------
92 *
93 * MULTICAST INVALIDATE
94 *
95 * flit 1
96 * ------------------------------------------------------------------------------------------------------------------
97 * EOP:0 | DEST(14 bits) | X (3 bits) | IS_CONFIG (1 bit) | MEMC_ID(14 bits) | UPDT_INDEX(4 bits) | TYPE:0b1X  | BC:0
98 * ------------------------------------------------------------------------------------------------------------------
99 *                                                                                                | X: 0 DATA  |
100 *                                                                                                |    1 INST  |
101 * flit 2
102 * ----------------------------------------------------------------------------------------------
103 * EOP:1 | X(5 bits) |                                                           NLINE (34 bits)
104 * ----------------------------------------------------------------------------------------------
105 *
106 * BROADCAST INVALIDATE
107 *
108 * flit 1
109 *       | BOUNDING BOX(20 bits)            |
110 * ----------------------------------------------------------------------------------------------
111 * EOP:0 | XMIN   | XMAX   | YMIN   | YMAX  | MEMC_ID(14 bits) | NETWORK_RESERVED(4 bits) | BC:1
112 * ----------------------------------------------------------------------------------------------
113 *
114 * flit 2
115 * ----------------------------------------------------------------------------------------------
116 * EOP:1 |        X(5 bits)       |                                              NLINE (34 bits)
117 * ----------------------------------------------------------------------------------------------
118 *
119 * M2P clack commands
120 *
121 * CLEANUP ACKNOWLEDGEMENT
122 *
123 * flit 1
124 * ----------------------------------------------------------------------------------------------
125 * EOP:1 | DEST(14 bits) | X(5 bits) | SET_INDEX(16 bits) | WAY_INDEX(2 bits) | TYPE:0bX   | BC:0
126 * ----------------------------------------------------------------------------------------------
127 *                                                                            | X: 0 CLACK |
128 *                                                                            |      DATA  |
129 *                                                                            |    1 CLACK |
130 *                                                                            |      INST  |
131 *
132 */
133
134/*
135 * Utility MACROS
136 */
137#define GET_FIELD(x,y)\
138    case y: return ((x >> y##_SHIFT) & y##_MASK)
139
140#define SET_FIELD(x,y,z)\
141    case z: x |= ((y & z##_MASK) << z##_SHIFT);break
142
143class DspinDhccpParam
144{
145  public:
146
147    static const uint8_t  m2p_flit_width               = 40;
148    static const uint8_t  p2m_flit_width               = 33;
149    static const uint8_t  clack_flit_width             = 40;
150
151    static const uint8_t  UPDT_INDEX_WIDTH             = 4;
152    static const uint8_t  NLINE_WIDTH                  = 34;
153    static const uint8_t  SRCID_WIDTH                  = 14;
154    static const uint8_t  GLOBALID_WIDTH               = 10;
155    static const uint8_t  WORD_INDEX_WIDTH             = 4;
156    static const uint8_t  BE_WIDTH                     = 4;
157    static const uint8_t  DATA_WIDTH                   = 32;
158    static const uint8_t  SET_INDEX_WIDTH              = 16;
159    static const uint8_t  WAY_INDEX_WIDTH              = 2;
160    static const uint8_t  BROADCAST_BOX_WIDTH          = 20;
161    static const uint8_t  M2P_TYPE_WIDTH               = 2;
162    static const uint8_t  P2M_TYPE_WIDTH               = 2;
163    static const uint8_t  CLACK_TYPE_WIDTH             = 1;
164
165    static const uint8_t  P2M_TYPE_SHIFT               = 1;
166    static const uint64_t P2M_TYPE_MASK                = ((1ULL<<P2M_TYPE_WIDTH)-1);
167    static const uint8_t  P2M_EOP_SHIFT                = 32;
168    static const uint64_t P2M_EOP_MASK                 = 1;
169    static const uint8_t  P2M_BC_SHIFT                 = 0;
170    static const uint64_t P2M_BC_MASK                  = 1;
171
172    static const uint8_t  CLEANUP_DEST_SHIFT           = 22;
173    static const uint64_t CLEANUP_DEST_MASK            = ((1ULL<<GLOBALID_WIDTH)-1);
174    static const uint8_t  CLEANUP_SRCID_SHIFT          = 8;
175    static const uint64_t CLEANUP_SRCID_MASK           = ((1ULL<<SRCID_WIDTH)-1);
176    static const uint8_t  CLEANUP_NLINE_MSB_SHIFT      = 6;
177    static const uint64_t CLEANUP_NLINE_MSB_MASK       = ((1ULL<< 2)-1);
178    static const uint8_t  CLEANUP_WAY_INDEX_SHIFT      = 3;
179    static const uint64_t CLEANUP_WAY_INDEX_MASK       = ((1ULL<<WAY_INDEX_WIDTH)-1);
180    static const uint8_t  CLEANUP_NLINE_LSB_SHIFT      = 0;
181    static const uint64_t CLEANUP_NLINE_LSB_MASK       = ((1ULL<<32)-1);
182    static const uint8_t  CLEANUP_DATA_UPDT_SHIFT      = 0;
183    static const uint64_t CLEANUP_DATA_UPDT_MASK       = ((1ULL<<32)-1);
184    static const uint8_t  CLEANUP_NCC_SHIFT            = 5;
185    static const uint64_t CLEANUP_NCC_MASK             = 1;
186
187    static const uint8_t  MULTI_ACK_DEST_SHIFT         = CLEANUP_DEST_SHIFT;
188    static const uint64_t MULTI_ACK_DEST_MASK          = CLEANUP_DEST_MASK;
189    static const uint8_t  MULTI_ACK_UPDT_INDEX_SHIFT   = 3;
190    static const uint64_t MULTI_ACK_UPDT_INDEX_MASK    = ((1ULL<<UPDT_INDEX_WIDTH)-1);
191
192    static const uint8_t  M2P_TYPE_SHIFT               = 1;
193    static const uint64_t M2P_TYPE_MASK                = ((1ULL<<M2P_TYPE_WIDTH)-1);
194    static const uint8_t  M2P_EOP_SHIFT                = 39;
195    static const uint64_t M2P_EOP_MASK                 = 1;
196    static const uint8_t  M2P_BC_SHIFT                 = 0;
197    static const uint64_t M2P_BC_MASK                  = 1;
198
199    static const uint8_t  MULTI_INVAL_DEST_SHIFT       = 25;
200    static const uint64_t MULTI_INVAL_DEST_MASK        = ((1ULL<<SRCID_WIDTH)-1);
201    static const uint8_t  MULTI_INVAL_SRCID_SHIFT      = 8;
202    static const uint64_t MULTI_INVAL_SRCID_MASK       = ((1ULL<<SRCID_WIDTH)-1);
203    static const uint8_t  MULTI_INVAL_UPDT_INDEX_SHIFT = 4;
204    static const uint64_t MULTI_INVAL_UPDT_INDEX_MASK  = ((1ULL<<UPDT_INDEX_WIDTH)-1);
205    static const uint8_t  MULTI_INVAL_NLINE_SHIFT      = 0;
206    static const uint64_t MULTI_INVAL_NLINE_MASK       = ((1ULL<<NLINE_WIDTH)-1);
207    static const uint8_t  MULTI_INVAL_IS_CONFIG_SHIFT  = 21;
208    static const uint64_t MULTI_INVAL_IS_CONFIG_MASK   = 1;
209
210    static const uint8_t  MULTI_UPDT_DEST_SHIFT        = MULTI_INVAL_DEST_SHIFT;
211    static const uint64_t MULTI_UPDT_DEST_MASK         = MULTI_INVAL_DEST_MASK;
212    static const uint8_t  MULTI_UPDT_SRCID_SHIFT       = MULTI_INVAL_SRCID_SHIFT;
213    static const uint64_t MULTI_UPDT_SRCID_MASK        = MULTI_INVAL_SRCID_MASK;
214    static const uint8_t  MULTI_UPDT_UPDT_INDEX_SHIFT  = MULTI_INVAL_UPDT_INDEX_SHIFT;
215    static const uint64_t MULTI_UPDT_UPDT_INDEX_MASK   = MULTI_INVAL_UPDT_INDEX_MASK;
216    static const uint8_t  MULTI_UPDT_WORD_INDEX_SHIFT  = 34;
217    static const uint64_t MULTI_UPDT_WORD_INDEX_MASK   = ((1ULL<<WORD_INDEX_WIDTH)-1);
218    static const uint8_t  MULTI_UPDT_NLINE_SHIFT       = MULTI_INVAL_NLINE_SHIFT;
219    static const uint64_t MULTI_UPDT_NLINE_MASK        = MULTI_INVAL_NLINE_MASK;
220    static const uint8_t  MULTI_UPDT_BE_SHIFT          = 32;
221    static const uint64_t MULTI_UPDT_BE_MASK           = ((1ULL<<BE_WIDTH)-1);
222    static const uint8_t  MULTI_UPDT_DATA_SHIFT        = 0;
223    static const uint64_t MULTI_UPDT_DATA_MASK         = ((1ULL<<DATA_WIDTH)-1);
224
225    static const uint8_t  BROADCAST_BOX_SHIFT          = 19;
226    static const uint64_t BROADCAST_BOX_MASK           = ((1ULL<<BROADCAST_BOX_WIDTH)-1);
227    static const uint8_t  BROADCAST_SRCID_SHIFT        = 5;
228    static const uint64_t BROADCAST_SRCID_MASK         = MULTI_INVAL_SRCID_MASK;
229    static const uint8_t  BROADCAST_NLINE_SHIFT        = 0;
230    static const uint64_t BROADCAST_NLINE_MASK         = MULTI_INVAL_NLINE_MASK;
231
232    static const uint8_t  CLACK_TYPE_SHIFT             = 1;
233    static const uint64_t CLACK_TYPE_MASK              = ((1ULL<<CLACK_TYPE_WIDTH)-1);
234    static const uint8_t  CLACK_EOP_SHIFT              = 39;
235    static const uint64_t CLACK_EOP_MASK               = 1;
236    static const uint8_t  CLACK_BC_SHIFT               = 0;
237    static const uint64_t CLACK_BC_MASK                = 1;
238    static const uint8_t  CLACK_DEST_SHIFT             = 25;
239    static const uint64_t CLACK_DEST_MASK              = ((1ULL<<SRCID_WIDTH)-1);
240    static const uint8_t  CLACK_SET_SHIFT              = 6;
241    static const uint64_t CLACK_SET_MASK               = ((1ULL<<SET_INDEX_WIDTH)-1);
242    static const uint8_t  CLACK_WAY_SHIFT              = 4;
243    static const uint64_t CLACK_WAY_MASK               = ((1ULL<<WAY_INDEX_WIDTH)-1);
244
245    /*
246     * P2M command types
247     */
248    enum
249    {
250      TYPE_MULTI_ACK    = 0,
251      TYPE_CLEANUP      = 2,
252      TYPE_CLEANUP_DATA = TYPE_CLEANUP,
253      TYPE_CLEANUP_INST = 3
254    };
255
256    /*
257     * M2P command types
258     */
259    enum
260    {
261      TYPE_MULTI_UPDT       = 0,
262      TYPE_MULTI_UPDT_DATA  = TYPE_MULTI_UPDT,
263      TYPE_MULTI_UPDT_INST  = 1,
264      TYPE_MULTI_INVAL      = 2,
265      TYPE_MULTI_INVAL_DATA = TYPE_MULTI_INVAL,
266      TYPE_MULTI_INVAL_INST = 3
267    };
268
269    /*
270     * CLACK command types
271     */
272    enum
273    {
274      TYPE_CLACK      = 0,
275      TYPE_CLACK_DATA = TYPE_CLACK,
276      TYPE_CLACK_INST = 1
277    };
278
279    enum flit_field_e
280    {
281      P2M_TYPE,
282      P2M_EOP,
283      P2M_BC,
284
285      CLEANUP_DEST,
286      CLEANUP_SRCID,
287      CLEANUP_NLINE_MSB,
288      CLEANUP_WAY_INDEX,
289      CLEANUP_NLINE_LSB,
290      CLEANUP_DATA_UPDT,
291      CLEANUP_NCC,
292
293      MULTI_ACK_DEST,
294      MULTI_ACK_UPDT_INDEX,
295
296      M2P_TYPE,
297      M2P_EOP,
298      M2P_BC,
299
300      MULTI_INVAL_DEST,
301      MULTI_INVAL_SRCID,
302      MULTI_INVAL_UPDT_INDEX,
303      MULTI_INVAL_NLINE,
304      MULTI_INVAL_IS_CONFIG,
305
306      MULTI_UPDT_DEST,
307      MULTI_UPDT_SRCID,
308      MULTI_UPDT_UPDT_INDEX,
309      MULTI_UPDT_WORD_INDEX,
310      MULTI_UPDT_NLINE,
311      MULTI_UPDT_BE,
312      MULTI_UPDT_DATA,
313
314      CLACK_TYPE,
315
316      CLACK_DEST,
317      CLACK_SET,
318      CLACK_WAY,
319
320      BROADCAST_BOX,
321      BROADCAST_SRCID,
322      BROADCAST_NLINE
323    };
324
325    static uint64_t dspin_get(uint64_t flit, flit_field_e field)
326    {
327      switch(field)
328      {
329        GET_FIELD(flit,P2M_TYPE);
330        GET_FIELD(flit,P2M_EOP);
331        GET_FIELD(flit,P2M_BC);
332        GET_FIELD(flit,CLEANUP_DEST);
333        GET_FIELD(flit,CLEANUP_SRCID);
334        GET_FIELD(flit,CLEANUP_NLINE_MSB);
335        GET_FIELD(flit,CLEANUP_WAY_INDEX);
336        GET_FIELD(flit,CLEANUP_NLINE_LSB);
337        GET_FIELD(flit,CLEANUP_DATA_UPDT);
338        GET_FIELD(flit,CLEANUP_NCC);
339        GET_FIELD(flit,MULTI_ACK_DEST);
340        GET_FIELD(flit,MULTI_ACK_UPDT_INDEX);
341        GET_FIELD(flit,M2P_TYPE);
342        GET_FIELD(flit,M2P_EOP);
343        GET_FIELD(flit,M2P_BC);
344        GET_FIELD(flit,MULTI_INVAL_DEST);
345        GET_FIELD(flit,MULTI_INVAL_SRCID);
346        GET_FIELD(flit,MULTI_INVAL_UPDT_INDEX);
347        GET_FIELD(flit,MULTI_INVAL_NLINE);
348        GET_FIELD(flit,MULTI_INVAL_IS_CONFIG);
349        GET_FIELD(flit,MULTI_UPDT_DEST);
350        GET_FIELD(flit,MULTI_UPDT_SRCID);
351        GET_FIELD(flit,MULTI_UPDT_UPDT_INDEX);
352        GET_FIELD(flit,MULTI_UPDT_WORD_INDEX);
353        GET_FIELD(flit,MULTI_UPDT_NLINE);
354        GET_FIELD(flit,MULTI_UPDT_BE);
355        GET_FIELD(flit,MULTI_UPDT_DATA);
356        GET_FIELD(flit,CLACK_TYPE);
357        GET_FIELD(flit,CLACK_DEST);
358        GET_FIELD(flit,CLACK_SET);
359        GET_FIELD(flit,CLACK_WAY);
360        GET_FIELD(flit,BROADCAST_BOX);
361        GET_FIELD(flit,BROADCAST_SRCID);
362        GET_FIELD(flit,BROADCAST_NLINE);
363
364        default: assert(false && "Incorrect DHCCP DSPIN field");
365      }
366    }
367
368    static void dspin_set(uint64_t &flit, uint64_t value, flit_field_e field)
369    {
370      switch(field)
371      {
372        SET_FIELD(flit,value,P2M_TYPE);
373        SET_FIELD(flit,value,P2M_EOP);
374        SET_FIELD(flit,value,P2M_BC);
375        SET_FIELD(flit,value,CLEANUP_DEST);
376        SET_FIELD(flit,value,CLEANUP_SRCID);
377        SET_FIELD(flit,value,CLEANUP_NLINE_MSB);
378        SET_FIELD(flit,value,CLEANUP_WAY_INDEX);
379        SET_FIELD(flit,value,CLEANUP_NLINE_LSB);
380        SET_FIELD(flit,value,CLEANUP_DATA_UPDT);
381        SET_FIELD(flit,value,CLEANUP_NCC);
382        SET_FIELD(flit,value,MULTI_ACK_DEST);
383        SET_FIELD(flit,value,MULTI_ACK_UPDT_INDEX);
384        SET_FIELD(flit,value,M2P_TYPE);
385        SET_FIELD(flit,value,M2P_EOP);
386        SET_FIELD(flit,value,M2P_BC);
387        SET_FIELD(flit,value,MULTI_INVAL_DEST);
388        SET_FIELD(flit,value,MULTI_INVAL_SRCID);
389        SET_FIELD(flit,value,MULTI_INVAL_UPDT_INDEX);
390        SET_FIELD(flit,value,MULTI_INVAL_NLINE);
391        SET_FIELD(flit,value,MULTI_INVAL_IS_CONFIG);
392        SET_FIELD(flit,value,MULTI_UPDT_DEST);
393        SET_FIELD(flit,value,MULTI_UPDT_SRCID);
394        SET_FIELD(flit,value,MULTI_UPDT_UPDT_INDEX);
395        SET_FIELD(flit,value,MULTI_UPDT_WORD_INDEX);
396        SET_FIELD(flit,value,MULTI_UPDT_NLINE);
397        SET_FIELD(flit,value,MULTI_UPDT_BE);
398        SET_FIELD(flit,value,MULTI_UPDT_DATA);
399        SET_FIELD(flit,value,CLACK_TYPE);
400        SET_FIELD(flit,value,CLACK_DEST);
401        SET_FIELD(flit,value,CLACK_SET);
402        SET_FIELD(flit,value,CLACK_WAY);
403        SET_FIELD(flit,value,BROADCAST_BOX);
404        SET_FIELD(flit,value,BROADCAST_SRCID);
405        SET_FIELD(flit,value,BROADCAST_NLINE);
406
407        default: assert(false && "Incorrect DHCCP DSPIN field");
408      }
409    }
410};
411
412#undef GET_FIELD
413#undef SET_FIELD
414
415}} // end namespace soclib::caba
416
417#endif
418// Local Variables:
419// tab-width: 2
420// c-basic-offset: 2
421// c-file-offsets:((innamespace . 0)(inline-open . 0))
422// indent-tabs-mode: nil
423// End:
424
425// vim: filetype=cpp:expandtab:shiftwidth=2:tabstop=2:softtabstop=2
Note: See TracBrowser for help on using the repository browser.