source: trunk/platforms/tsarv4_mono_nommu/top.cpp @ 364

Last change on this file since 364 was 208, checked in by alain, 13 years ago

Introducing a mono-processor architecture using the cc_xcache_v4
  • Property svn:executable set to *
File size: 11.8 KB
Line 
1
2#include <systemc>
3#include <sys/time.h>
4#include <iostream>
5#include <cstdlib>
6#include <cstdarg>
7
8#ifdef _OPENMP
9#include <omp.h>
10#endif
11
12#include "mapping_table.h"
13#include "mips32.h"
14#include "vci_simple_ram.h"
15#include "vci_multi_tty.h"
16#include "vci_vgmn.h"
17#include "vci_mem_cache_v4.h"
18#include "vci_cc_xcache_wrapper_v4.h"
19#include "vci_xicu.h"
20#include "vci_simhelper.h"
21#include "vci_multi_dma.h"
22
23// VCI format
24
25#define    cell_width            4
26#define    address_width         32
27#define    plen_width            8
28#define    error_width           2
29#define    clen_width            1
30#define    rflag_width           1
31#define    srcid_width           14
32#define    pktid_width           4
33#define    trdid_width           4
34#define    wrplen_width          1
35
36//   segments definition in direct space
37
38#define    XICU_BASE    0xd8200000
39#define    XICU_SIZE    0x00001000
40
41#define    MDMA_BASE    0xe8000000
42#define    MDMA_SIZE    0x00000014
43
44#define    MTTY_BASE    0xd0200000
45#define    MTTY_SIZE    0x00000010
46
47#define    EXIT_BASE    0xe0000000
48#define    EXIT_SIZE    0x00000010
49
50#define    BOOT_BASE    0xbfc00000
51#define    BOOT_SIZE    0x00040000
52
53#define    MEMC_BASE    0x00000000
54#define    MEMC_SIZE    0x02000000
55
56//  segments definition in coherence space
57
58#define    C_L1_BASE    0x10000000
59#define    C_L1_SIZE    0x00000010
60
61#define    C_MC_BASE    0x00000000
62#define    C_MC_SIZE    0x02000010
63
64#define    C_BR_BASE    0xbfc00000
65#define    C_BR_SIZE    0x00040000
66
67/////////////////////////////////
68int _main(int argc, char *argv[])
69{
70
71using namespace sc_core;
72using namespace soclib::common;
73using namespace soclib::caba;
74
75#ifdef _OPENMP
76        omp_set_dynamic(false);
77        omp_set_num_threads(1);
78        std::cerr << "Built with openmp version " << _OPENMP << std::endl;
79#endif
80
81    char        soft_name[256]  = "test.elf";   // pathname to binary code
82    size_t      ncycles         = 1000000000;   // max number of simulation cycles
83    bool        trace_ok        = false;
84    size_t      from_cycle      = 0;            // debug start cycle
85    size_t      max_frozen      = 1000;         // max number of frozen cycles
86
87    /////////////// command line arguments ////////////////
88    if (argc > 1)
89    {
90        for( int n=1 ; n<argc ; n=n+2 )
91        {
92            if( (strcmp(argv[n],"-NCYCLES") == 0) && (n+1<argc) )
93            {
94                ncycles = atoi(argv[n+1]);
95            }
96            else if( (strcmp(argv[n],"-SOFT") == 0) && (n+1<argc) )
97            {
98                strcpy(soft_name, argv[n+1]);
99            }
100            else if( (strcmp(argv[n],"-TRACE") == 0) && (n+1<argc) )
101            {
102                trace_ok = true;
103                from_cycle = atoi(argv[n+1]);
104            }
105            else if( (strcmp(argv[n],"-MAXFROZEN") == 0) && (n+1<argc) )
106            {
107                max_frozen = atoi(argv[n+1]);
108            }
109            else
110            {
111                std::cout << "   Arguments on the command line are (key,value) couples." << std::endl;
112                std::cout << "   The order is not important." << std::endl;
113                std::cout << "   Accepted arguments are :" << std::endl << std::endl;
114                std::cout << "     -SOFT pathname_for_embedded_soft" << std::endl;
115                std::cout << "     -NCYCLES number_of_simulated_cycles" << std::endl;
116                std::cout << "     -TRACE debug_start_cycle" << std::endl;
117                exit(0);
118            }
119        }
120    }
121
122    // Define VCI parameters
123    typedef VciParams<cell_width,
124                                    plen_width,
125                                    address_width,
126                                    error_width,
127                                    clen_width,
128                                    rflag_width,
129                                    srcid_width,
130                                    pktid_width,
131                                    trdid_width,
132                                    wrplen_width> vci_param;
133
134    // Define processor type
135    typedef soclib::common::Mips32ElIss proc_iss;
136
137    // Mapping table for direct network
138    soclib::common::MappingTable maptabd(32, IntTab(6), IntTab(6), 0xF0000000);
139    maptabd.add(Segment("memc_d" , MEMC_BASE , MEMC_SIZE , IntTab(0), true));
140    maptabd.add(Segment("boot_d" , BOOT_BASE , BOOT_SIZE , IntTab(1), true));
141    maptabd.add(Segment("exit_d" , EXIT_BASE , EXIT_SIZE , IntTab(2), false));
142    maptabd.add(Segment("mtty_d" , MTTY_BASE , MTTY_SIZE , IntTab(3), false));
143    maptabd.add(Segment("xicu_d" , XICU_BASE , XICU_SIZE , IntTab(4), false));
144    maptabd.add(Segment("mdma_d" , MDMA_BASE , MDMA_SIZE , IntTab(5), false));
145    std::cout << maptabd << std::endl;
146
147    // Mapping table for coherence network
148    soclib::common::MappingTable maptabc(32, IntTab(6), IntTab(6), 0xF0000000);
149    maptabc.add(Segment("proc_c" , C_L1_BASE , C_L1_SIZE , IntTab(0), false, true, IntTab(0)));
150    maptabc.add(Segment("memc_c" , C_MC_BASE , C_MC_SIZE , IntTab(1), false ));
151    maptabc.add(Segment("brom_c" , C_BR_BASE , C_BR_SIZE , IntTab(1), false ));
152    std::cout << maptabc << std::endl;
153       
154    // Signals
155
156    sc_clock    signal_clk                      ("signal_clk");
157    sc_signal<bool> signal_resetn               ("isgnal_resetn");
158   
159    sc_signal<bool> signal_mdma_irq             ("signal_mdma_irq");
160    sc_signal<bool> signal_mtty_irq             ("signal_mtty_irq");
161    sc_signal<bool> signal_proc_irq             ("signal_proc_irq"); 
162    sc_signal<bool> signal_false                ("signal_false");
163
164    VciSignals<vci_param> signal_vci_ini_d_proc ("vci_ini_d_proc");
165    VciSignals<vci_param> signal_vci_ini_c_proc ("vci_ini_c_proc");
166    VciSignals<vci_param> signal_vci_tgt_c_proc ("vci_tgt_c_proc");
167
168    VciSignals<vci_param> signal_vci_tgt_d_mtty ("signal_vci_tgt_d_mtty");
169
170    VciSignals<vci_param> signal_vci_tgt_d_exit ("signal_vci_tgt_d_exit");
171
172    VciSignals<vci_param> signal_vci_tgt_d_xicu ("signal_vci_tgt_d_xicu");
173
174    VciSignals<vci_param> signal_vci_ini_d_mdma ("signal_vci_ini_d_mdma");
175    VciSignals<vci_param> signal_vci_tgt_d_mdma ("signal_vci_tgt_d_mdma");
176
177    VciSignals<vci_param> signal_vci_tgt_d_brom ("signal_vci_tgt_d_brom");
178
179
180    VciSignals<vci_param> signal_vci_ini_c_memc ("signal_vci_ini_c_memc");
181    VciSignals<vci_param> signal_vci_tgt_d_memc ("signal_vci_tgt_d_memc");
182    VciSignals<vci_param> signal_vci_tgt_c_memc ("signal_vci_tgt_c_memc");
183
184    VciSignals<vci_param> signal_vci_xram       ("signal_vci_xram");
185
186    // Components
187
188    soclib::common::Loader loader(soft_name);
189
190    VciCcXCacheWrapperV4<vci_param, proc_iss > 
191    proc("proc", 
192         0,                     // proc_id
193         maptabd,               // direct space
194         maptabc,               // coherence space
195         IntTab(0),             // srcid_d
196         IntTab(0),             // srcid_c
197         IntTab(0),             // tgtid_c
198         4,64,16,               // icache size
199         4,64,16,               // dcache size
200         4, 4,                  // wbuf size
201         max_frozen);           // max frozen cycles
202
203    VciSimpleRam<vci_param> 
204    rom("rom", 
205         IntTab(1),             // tgtid_d
206         maptabd, 
207         loader);
208
209    VciSimpleRam<vci_param> 
210    xram("xram", 
211         IntTab(0),             // tgtid_d(RAM) = tgtid_d(MEMC)
212         maptabd, 
213         loader);
214
215    VciMemCacheV4<vci_param> 
216    memc("memc",
217         maptabd,
218         maptabc,
219         maptabd,
220         IntTab(0),             // srcid_x
221         IntTab(1),             // srcid_c
222         IntTab(0),             // tgtid_d
223         IntTab(1),             // tgtid_c
224         16,256,16,             // cache size
225         1024,                  // HEAP size
226         4,                     // TRT size
227         4,                     // UPT size
228         from_cycle, trace_ok);
229       
230    VciSimhelper<vci_param> 
231    vciexit("vciexit",
232         IntTab(2),             // tgtid_d
233         maptabd);
234
235    VciXicu<vci_param> 
236    xicu("xicu", 
237         maptabd,
238         IntTab(4),             // tgtid_d
239         1,                     // number of timers
240         2,                     // number of hard interrupts
241         0,                     // number of soft interrupts
242         1);                    // number of output IRQs
243
244    VciMultiTty<vci_param> 
245    mtty("mtty", 
246         IntTab(3),             // tgtid_d
247         maptabd, 
248         "mtty0", NULL);
249
250    VciMultiDma<vci_param>
251    mdma("mdma", 
252         maptabd, 
253         IntTab(1),             // srcid_d
254         IntTab(5),             // tgtid_d
255         64,                    // burst size
256         1);                    // number of channels
257       
258    VciVgmn<vci_param> 
259    ringd("ringd",
260         maptabd, 
261         2,                     // number of initiators
262         6,                     // number of targets
263         2, 
264         8);
265
266    VciVgmn<vci_param> 
267    ringc("ringc",
268         maptabc, 
269         2,                     // number of initiators
270         2,                     // number of targets
271         2, 
272         8);
273
274    // net-list
275    proc.p_clk(signal_clk); 
276    proc.p_resetn               (signal_resetn); 
277    proc.p_irq[0]               (signal_proc_irq); 
278    proc.p_irq[1]               (signal_false); 
279    proc.p_irq[2]               (signal_false); 
280    proc.p_irq[3]               (signal_false); 
281    proc.p_irq[4]               (signal_false); 
282    proc.p_irq[5]               (signal_false); 
283    proc.p_vci_ini_d            (signal_vci_ini_d_proc);
284    proc.p_vci_ini_c            (signal_vci_ini_c_proc);
285    proc.p_vci_tgt_c            (signal_vci_tgt_c_proc);
286
287    rom.p_clk                   (signal_clk);
288    rom.p_resetn                (signal_resetn);
289    rom.p_vci                   (signal_vci_tgt_d_brom);
290
291    xicu.p_resetn               (signal_resetn);
292    xicu.p_clk                  (signal_clk);
293    xicu.p_vci                  (signal_vci_tgt_d_xicu);
294    xicu.p_hwi[0]               (signal_mtty_irq);
295    xicu.p_hwi[1]               (signal_mdma_irq);
296    xicu.p_irq[0]               (signal_proc_irq);
297
298    mdma.p_clk                  (signal_clk);
299    mdma.p_resetn               (signal_resetn);
300    mdma.p_vci_target           (signal_vci_tgt_d_mdma);
301    mdma.p_vci_initiator        (signal_vci_ini_d_mdma);
302    mdma.p_irq[0]               (signal_mdma_irq); 
303
304    mtty.p_clk                  (signal_clk);
305    mtty.p_resetn               (signal_resetn);
306    mtty.p_vci                  (signal_vci_tgt_d_mtty);
307    mtty.p_irq[0]               (signal_mtty_irq); 
308
309    vciexit.p_clk               (signal_clk);
310    vciexit.p_resetn            (signal_resetn);
311    vciexit.p_vci               (signal_vci_tgt_d_exit);
312
313    memc.p_clk                  (signal_clk);
314    memc.p_resetn               (signal_resetn);
315    memc.p_vci_tgt              (signal_vci_tgt_d_memc);
316    memc.p_vci_tgt_cleanup      (signal_vci_tgt_c_memc);
317    memc.p_vci_ini              (signal_vci_ini_c_memc);
318    memc.p_vci_ixr              (signal_vci_xram);
319
320    xram.p_clk                  (signal_clk);
321    xram.p_resetn               (signal_resetn);
322    xram.p_vci                  (signal_vci_xram);
323       
324    ringc.p_clk                 (signal_clk);
325    ringc.p_resetn              (signal_resetn);
326    ringc.p_to_initiator[0]     (signal_vci_ini_c_proc);
327    ringc.p_to_initiator[1]     (signal_vci_ini_c_memc);
328    ringc.p_to_target[0]        (signal_vci_tgt_c_proc);
329    ringc.p_to_target[1]        (signal_vci_tgt_c_memc);
330
331    ringd.p_clk                 (signal_clk);
332    ringd.p_resetn              (signal_resetn);
333    ringd.p_to_initiator[0]     (signal_vci_ini_d_proc);
334    ringd.p_to_initiator[1]     (signal_vci_ini_d_mdma);
335    ringd.p_to_target[0]        (signal_vci_tgt_d_memc);
336    ringd.p_to_target[1]        (signal_vci_tgt_d_brom);
337    ringd.p_to_target[2]        (signal_vci_tgt_d_exit);
338    ringd.p_to_target[3]        (signal_vci_tgt_d_mtty);
339    ringd.p_to_target[4]        (signal_vci_tgt_d_xicu);
340    ringd.p_to_target[5]        (signal_vci_tgt_d_mdma);
341       
342    // simulation loop
343
344    sc_start(sc_core::sc_time(0, SC_NS));
345    signal_resetn = false;
346
347    sc_start(sc_core::sc_time(1, SC_NS));
348    signal_resetn = true;
349       
350    signal_false = false;
351
352    for ( size_t n=1 ; n<ncycles ; n++ )
353    {
354        if ( trace_ok and (n > from_cycle) )
355        {
356            std::cout << "****************** cycle " << std::dec << n
357                      << " ************************************************" << std::endl;
358            proc.print_trace();
359            memc.print_trace();
360            signal_vci_ini_d_proc.print_trace("proc_ini_d");
361            signal_vci_tgt_c_proc.print_trace("proc_tgt_c");
362            signal_vci_ini_c_proc.print_trace("proc_ini_c");
363            signal_vci_tgt_d_memc.print_trace("memc_tgt_d");
364            signal_vci_tgt_c_memc.print_trace("memc_tgt_c");
365            signal_vci_ini_c_memc.print_trace("memc_ini_c");
366            if ( signal_proc_irq.read() ) std::cout << "---- IRQ ----" << std::endl;
367        }
368        sc_start(sc_core::sc_time(1, SC_NS));
369    }
370    return EXIT_SUCCESS;
371}
372
373int sc_main (int argc, char *argv[])
374{
375        try {
376                return _main(argc, argv);
377        } catch (std::exception &e) {
378                std::cout << e.what() << std::endl;
379        } catch (...) {
380                std::cout << "Unknown exception occured" << std::endl;
381                throw;
382        }
383        return 1;
384}
Note: See TracBrowser for help on using the repository browser.