source: sources/src/entity.cc @ 56

Last change on this file since 56 was 52, checked in by meunier, 12 years ago

Code formatting in all source files.

File size: 16.3 KB
Line 
1/*------------------------------------------------------------\
2  |                                                             |
3  | Tool    :                  systemcass                       |
4  |                                                             |
5  | File    :                   entity.cc                       |
6  |                                                             |
7  | Author  :                 Buchmann Richard                  |
8  |                           Taktak Sami                       |
9  |                                                             |
10  | Date    :                   09_07_2004                      |
11  |                                                             |
12  \------------------------------------------------------------*/
13
14/*
15 * This file is part of the Disydent Project
16 * Copyright (C) Laboratoire LIP6 - Département ASIM
17 * Universite Pierre et Marie Curie
18 *
19 * Home page          : http://www-asim.lip6.fr/disydent
20 * E-mail             : mailto:richard.buchmann@lip6.fr
21 *
22 * This library is free software; you  can redistribute it and/or modify it
23 * under the terms  of the GNU Library General Public  License as published
24 * by the Free Software Foundation; either version 2 of the License, or (at
25 * your option) any later version.
26 *
27 * Disydent is distributed  in the hope  that it  will be
28 * useful, but WITHOUT  ANY WARRANTY; without even the  implied warranty of
29 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
30 * Public License for more details.
31 *
32 * You should have received a copy  of the GNU General Public License along
33 * with the GNU C Library; see the  file COPYING. If not, write to the Free
34 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
35 */
36
37#include <cstring>
38#include <iomanip>
39#include <list>
40#include <map>
41#include <vector>
42#include <cassert>
43
44#include "entity.h"
45#include "sc_port.h"
46#include "sc_signal.h"
47#include "sc_module.h"
48
49#ifdef HAVE_CONFIG_H
50#include "config.h"
51#endif
52
53using namespace std;
54
55namespace sc_core {
56
57equi_list_t equi_list;
58equi_table_t equi_table = NULL;
59
60ostream & operator << (ostream &, const entity &);
61ostream & operator << (ostream &, const equi_t &);
62
63struct predic4entity2equi_t_t {
64    bool operator() (const entity & e1, const entity & e2) const {
65        return e1.interface < e2.interface;
66    }
67};
68
69typedef std::map <entity, equi_list_t::iterator, predic4entity2equi_t_t> entity2equi_it_t;
70
71
72ostream & operator << (ostream & o, const entity2equi_it_t & m) {
73    entity2equi_it_t::const_iterator i;
74    for (i = m.begin(); i != m.end(); ++i) {
75        o << (i->first) << " : " << *(i->second) << "\n";
76    }
77    return o;
78}
79
80entity2equi_it_t equi_map;
81
82
83const equi_list_t & get_equi_list() {
84    return equi_list;
85}
86
87
88unsigned int max(unsigned int a, unsigned int b) {
89    return (a > b) ? a : b;
90}
91
92
93static int get_signal_table_size(const equi_list_t & e) {
94    // bug fix : remove the 0x0 equi from the list
95    equi_list_t::const_iterator i;
96    int capacity = 0;
97    for (i = e.begin(); i != e.end(); ++i) {
98        //cerr << i->begin()->object->name ();
99        const entity & ent = *(i->begin());
100        int data_size = ent.data_size_in_bytes();
101        int number_of_part = ((data_size - 1) / sizeof(tab_t)) + 1;
102        capacity += number_of_part;
103    }
104    return capacity;
105}
106
107
108int get_signal_table_size() {
109    return get_signal_table_size(equi_list);
110}
111
112
113sc_port_base * get_out_port(const equi_t & eq) {
114    equi_t::const_iterator i;
115    for (i = eq.begin(); i != eq.end(); ++i) {
116        const char * type = i->kind();
117        if ((type == sc_core::sc_out_string) || (type == sc_core::sc_inout_string)) {
118            return i->port;
119        }
120    }
121    return NULL;
122}
123
124static sc_port_base *get_localvar(equi_t & eq) {
125    equi_t::iterator i;
126    for (i = eq.begin(); i != eq.end(); ++i) {
127        const char *type = i->kind();
128        if (strcmp(type, "sc_localvar") == 0) {
129            return i->port;
130        }
131    }
132    return NULL;
133}
134
135
136static sc_port_base *get_signal(equi_t & eq) {
137    equi_t::iterator i;
138    for (i = eq.begin(); i != eq.end(); ++i) {
139        const char * type = i->kind();
140        if (strcmp(type, "sc_signal") == 0) {
141            return i->port;
142        }
143    }
144    return NULL;
145}
146
147
148equi_t & get_equi(const sc_interface & i) {
149    return get_equi(i.get_pointer());
150}
151
152
153struct predic4tab_t2equi_t_t {
154    bool operator() (const tab_t * t1, const tab_t * t2) const {
155        return t1 < t2;
156    }
157};
158
159
160#define get_equi_SPEEDUP
161equi_t & get_equi(const tab_t * pointer) {
162    // result variable
163    equi_list_t::iterator i;
164#if defined(get_equi_SPEEDUP)
165    typedef std::map <const tab_t *, equi_list_t::iterator, predic4tab_t2equi_t_t> tab_t2equi_it_t;
166    static tab_t2equi_it_t tab2equi_map;
167    assert(pointer != NULL);
168
169    // boost
170    tab_t2equi_it_t:: /*const_ */ iterator it = tab2equi_map.find(pointer);
171    if (it != tab2equi_map.end()) {
172        i = it->second;
173        return *i;
174    }
175#endif
176
177   
178    for (i = equi_list.begin(); i != equi_list.end(); ++i) {
179        const equi_t::iterator & j = i->begin();
180        const entity & e = *j;
181        const sc_interface * f = e.interface;
182        const tab_t * p = f->get_pointer();
183        if (p == pointer) {
184#if defined(get_equi_SPEEDUP)
185            tab2equi_map[pointer] = i;
186#endif
187            return *i;
188        }
189    }
190    cerr << "Internal error : get_equi(" << pointer << ")\n";
191    exit(11);
192}
193#undef get_equi_SPEEDUP
194
195
196bool has_equi( /*const */ sc_port_base & port) {
197    entity e(port);
198    entity2equi_it_t::/*const_ */iterator it = equi_map.find(e);
199    if (it == equi_map.end()) {
200        return false;
201    }
202    return true;
203}
204
205
206static bool is_register(const equi_t & eq) {
207    return eq.size() == 1;
208}
209
210static int count_level(const char * s, char c) {
211    int i;
212    int counter = 0;
213    for (i = 0; s[i] != '\0'; ++i) {
214        if (s[i] == c) {
215            ++counter;
216        }
217    }
218    return counter;
219}
220
221
222const char * get_name(const equi_t & e) {
223    equi_t::const_iterator top_iter = e.begin();
224#ifdef CONFIG_DEBUG
225    if (top_iter == e.end()) {
226        cerr << "Internal error : no signal in " << e << endl;
227        exit(25);
228    }
229    if (top_iter->object == NULL) {
230        cerr << "Internal error : no object bound to ";
231        cerr << *top_iter;
232        cerr << endl;
233        exit(26);
234    }
235    if (top_iter->object->name() == NULL) {
236        cerr << "Internal error : signal has no name.\n";
237        cerr << *top_iter;
238        cerr << endl;
239    }
240#endif
241    int top_level = count_level(top_iter->object->name(), '.');
242    equi_t::const_iterator i;
243    for (i = ++(e.begin()); i != e.end(); ++i) {
244        int current_level = count_level(i->object->name(), '.');
245        if (current_level < top_level) {
246            top_iter = i;
247            top_level = current_level;
248        }
249    }
250#if 0
251    cerr << "get_name of " << e;
252    cerr << " return " << top_iter->object->name() << endl;
253#endif
254    return top_iter->object->name();
255}
256
257
258const char *get_name(const tab_t * pointer) {
259    return get_name(get_equi(pointer));
260}
261
262
263static const sc_module & get_module(const string & s) {
264    instances_set_t::iterator i;
265    for (i = instances_set.begin(); i != instances_set.end(); ++i) {
266        if (strcmp((*i)->name(), s.c_str()) == 0) {
267            return **i;
268        }
269    }
270    cerr << "Internal error : get_module\n";
271    exit(27);
272}
273
274
275template < typename T > static equi_list_t::iterator get_equi(T & e) {
276    entity2equi_it_t::iterator it = equi_map.find(entity(e));
277    if (it == equi_map.end()) {
278        return equi_list.end();
279    }
280    return it->second;
281}
282
283
284template < typename T > static void add_equi(equi_list_t::iterator & x, T & y) {
285    entity e(y);
286    x->push_back(e);
287    equi_map[e] = x;
288}
289
290
291template < typename T > static
292equi_list_t::iterator new_equi(T & x) { /* parameter is not 'const' because we need to modify pointer port/signal at end of elaboration step */
293    equi_list_t::iterator it = equi_list.insert(equi_list.begin(), equi_t(1, entity(x)));
294    equi_map[entity(x)] = it;
295    return it;
296}
297
298
299// sort by number of connected ports  bound to the signal
300static int operator <(const equi_t & e1, const equi_t & e2) {
301    return (e1.size() < e2.size());
302}
303
304// sort by data size
305/*
306    int operator<(const equi_t &e1, const equi_t &e2)
307    {
308    return (e1.begin()->data_size () < e2.begin()->data_size ());
309    }
310    */
311// random sort
312/*
313    int operator<(const equi_t &e1, const equi_t &e2)
314    {
315    typedef std::map<const equi_t*,int> m_t;
316    static m_t m;
317    if (m[&e1] == 0)
318    m[&e1] = rand ();
319    if (m[&e2] == 0)
320    m[&e2] = rand ();
321    return m[&e1] < m[&e2];
322    }
323    */
324
325void sort_equi_list() {
326    //load ();
327    equi_list.sort();
328    //equi_list.reverse ();
329}
330
331
332#if defined(DUMP_SIGNAL_STATS)
333static unsigned int equi_real_size;
334#endif
335
336unsigned int get_sizeof_signals_table() {
337    equi_list_t::iterator i;
338    int table_size = 0;
339    //cerr << "external table includes :\n";
340    for (i = equi_list.begin(); i != equi_list.end(); ++i) {
341        if (get_out_port(*i)) {
342            continue;
343        }
344        if (get_signal(*i)) {
345            continue;
346        }
347        //cerr << get_name (*i) << " ";
348        const entity & ent = *(i->begin());
349        int data_size = ent.data_size_in_bytes();
350        int number_of_part = ((data_size - 1) / sizeof(tab_t)) + 1;
351        table_size += number_of_part;
352    }
353    return table_size;
354}
355
356
357void create_signals_table() {
358    if (dump_stage) {
359        cerr << "Allocating signals table.\n";
360    }
361    unsigned int table_size = get_sizeof_signals_table();
362    equi_table = new tab_t[table_size]; //(0xCD);
363#if defined(DUMP_SIGNAL_STATS)
364    equi_real_size = table_size;
365#endif
366#if defined(INIT_SIGNALS_TO_ZERO)
367    memset(equi_table, 0, sizeof(tab_t) * table_size);
368#else
369    memset(equi_table, 0xCD, sizeof(tab_t) * table_size);
370#endif
371}
372
373
374static void bind_equi_to_table(equi_t & e, tab_t * const pointer) {
375    assert(pointer != NULL);
376    equi_t::iterator i;
377    for (i = e.begin(); i != e.end(); ++i) {
378        sc_interface *const inter = i->interface;
379        inter->set_pointer(pointer);
380        // We can't initialize data to zero there
381        // because we can't write the right amount of bits.
382        // It may produce some segmentation fault errors.
383        // The pointer is aligned to 32 bits.
384    }
385}
386
387
388void bind_to_table() {
389    if (dump_stage) {
390        cerr << "Binding ports/signals to the table.\n";
391    }
392    equi_list_t::iterator i;
393    int index = 0;
394    for (i = equi_list.begin(); i != equi_list.end(); ++i) {
395        sc_interface *out = get_out_port(*i);
396        if (out) {
397            bind_equi_to_table(*i, out->get_pointer());
398        }
399        else {
400            sc_interface * reg = get_signal(*i);
401            if (reg == NULL) {
402                reg = get_localvar(*i);
403            }
404            if (reg) {
405                bind_equi_to_table(*i, reg->get_pointer());
406            }
407            else {
408                bind_equi_to_table(*i, &(equi_table[index]));
409                index += (i->begin()->data_size_in_bytes() - 1) / sizeof(tab_t) + 1;
410            }
411        }
412    }
413}
414
415
416ostream & operator <<(ostream & o, const entity & e) {
417#if 0
418    o << "entity (";
419    if (e.object)
420        o << e.object->name();
421    else
422        o << "no object";
423    if (e.interface)
424        o << ", pointer = 0x" << hex << e.interface->get_pointer();
425    else
426        o << ", no interface";
427    o << ")";
428#else
429    assert(e.object != NULL);
430    o << e.object->name();
431#endif
432    return o;
433}
434
435ostream & operator <<(ostream & o, const equi_t & e) {
436    bool nb = 0;
437    equi_t::const_iterator i;
438    for (i = e.begin(); i != e.end(); ++i) {
439        const entity & ity = *i;
440        o << ((nb++) ? " = " : "") << ity;
441    }
442    return o;
443}
444
445
446void print_table(ostream & o) {
447    o << "Signal list\n" << "-----------\n";
448    equi_list_t::const_iterator i;
449    for (i = equi_list.begin(); i != equi_list.end(); ++i) {
450        const equi_t & eq = *i;
451#if 0
452        o << i->begin()->interface->get_pointer() << " : ";
453        o << (*i);
454        o << "\n";
455#else
456        o << "(" << get_name(eq) << ") <=> " << eq << ".\n";
457#endif
458    }
459}
460
461void print_table_stats(ostream & o) {
462#if defined(DUMP_SIGNAL_STATS)
463    int nb_reg = 0;
464    int nb_sig = 0;
465    int real_size = 0;
466
467    // count
468    equi_list_t::const_iterator i;
469    int num;
470    for (num = 0, i = equi_list.begin(); i != equi_list.end(); ++num, ++i) {
471        if (is_register(*i)) {
472            ++nb_reg;
473        }
474        else {
475            ++nb_sig;
476        }
477    }
478
479    // print results
480    o << "Statistics :\n";
481    o << "#registers : " << nb_reg << endl;
482    o << "#signals : " << nb_sig << endl;
483    o << "current table size : " << equi_real_size << endl;
484#endif
485}
486
487
488#ifdef DUMP_SIGNAL_STATS
489typedef map < tab_t *, long long int > counter_t;
490static counter_t counter;
491long long int unnecessary = 0;
492long long int total_assig = 0;
493#endif
494
495const char * get_module_name(const equi_t & eq) {
496    if (!is_register(eq)) {
497        /*
498        cerr << "get_module_name doesn't work yet upon non-register.\n";
499        */
500        return "top_level";
501    }
502    const entity & ent = *(eq.begin());
503
504#ifdef CONFIG_DEBUG
505    if (ent.type != sc_core::entity::SIGNAL) {
506        exit(28);
507    }
508#endif
509
510    // get module name from sc_signal used like a register
511    const char * sig_name = ent.object->name();
512    const char * sep = strchr(sig_name, '.');
513
514#ifdef CONFIG_DEBUG
515    if (sep == NULL) {
516        exit(30);
517    }
518#endif
519
520    int end_pos = sep - sig_name;
521    string module_name(sig_name, end_pos);
522    // can't return the char* pointer from string since it will be invalid.
523    return get_module(module_name).name();
524}
525
526
527static void merge_equi(equi_list_t::iterator & x, equi_list_t::iterator & y) {
528    equi_t::iterator i;
529    equi_t & y2 = *y;
530    for (i = y2.begin(); i != y2.end(); ++i) {
531        entity & e = *i;
532        equi_map[e] = x;
533    }
534
535    x->merge(*y);
536    equi_list.erase(y);
537}
538
539
540// sort by data size
541#ifdef DATASIZE_SORT
542int operator< (const equi_t & e1, const equi_t & e2) {
543    return (e1.begin()->data_size() < e2.begin()->data_size());
544}
545#endif
546
547
548// random sort
549#ifdef RANDOM_SORT
550int operator< (const equi_t & e1, const equi_t & e2) {
551    typedef std::map < const equi_t *, int > m_t;
552    static m_t m;
553    if (m[&e1] == 0) {
554        m[&e1] = rand();
555    }
556    if (m[&e2] == 0) {
557        m[&e2] = rand();
558    }
559    return m[&e1] < m[&e2];
560}
561#endif
562
563
564#if defined(DUMP_SIGNAL_STATS)
565static unsigned int equi_real_size;
566#endif
567
568
569void bind(sc_signal_base & x) {
570#if 0
571    //defined(CONFIG_DEBUG)
572    equi_list_t::iterator x_equi = get_equi(x);
573    if ((x_equi != equi_list.end())) {
574        cerr << "Internal error : Signal already in the table\n";
575        return;
576    }
577#endif
578    new_equi(x);
579}
580
581
582void bind(sc_port_base & x) {
583    new_equi(x);
584}
585
586
587template < typename T > static void test_before_bind(sc_port_base & p1, T & p2) {
588    bool t1 = (p1.kind() != NULL);
589    bool t2 = (p2.kind() != NULL);
590    if (t1 && t2) {
591        return;
592    }
593    if (t1 == true) {
594        cerr << "Trying to bind '" << p1.name() << "' to an unknown type.\n";
595    }
596    else if (t2 == true) {
597        cerr << "Trying to bind '" << p2.name() << "' to an unknown type.\n";
598    }
599    else {
600        cerr << "Binding failed. Please check the netlist description.\n";
601    }
602    exit(20040525);
603}
604
605
606template < typename T > static void tbind(sc_port_base & x, T & y) {
607    // assert(x.get_pointer () != NULL); // x pointer may be NULL
608    // assert(y.get_pointer () != NULL); // y pointer may be NULL
609    equi_list_t::iterator x_equi = get_equi(x);
610    equi_list_t::iterator y_equi = get_equi(y);
611    if ((x_equi != equi_list.end()) && (y_equi != equi_list.end())) {
612        // 2 equipotentials are equals
613        merge_equi(x_equi, y_equi);
614    }
615    else if ((x_equi != equi_list.end())) {
616        // add y
617        add_equi(x_equi, y);
618    }
619    else if ((y_equi != equi_list.end())) {
620        // add y
621        add_equi(y_equi, x);
622    }
623    else {
624        // add a new equi
625        x_equi = new_equi(x);
626        add_equi(x_equi, y);
627    }
628}
629
630
631void bind(sc_port_base & p1, sc_port_base & p2) {
632    test_before_bind(p1, p2);
633    tbind(p1, p2);
634}
635
636
637void bind(sc_port_base & p1, sc_signal_base & s1) {
638    test_before_bind(p1, s1);
639    tbind(p1, s1);
640}
641
642
643} // end of sc_core namespace
644
645/*
646# Local Variables:
647# tab-width: 4;
648# c-basic-offset: 4;
649# c-file-offsets:((innamespace . 0)(inline-open . 0));
650# indent-tabs-mode: nil;
651# End:
652#
653# vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
654*/
655
Note: See TracBrowser for help on using the repository browser.