test12.cpp revision 12855:588919e0e4aa 
1/*****************************************************************************
2
3  Licensed to Accellera Systems Initiative Inc. (Accellera) under one or
4  more contributor license agreements.  See the NOTICE file distributed
5  with this work for additional information regarding copyright ownership.
6  Accellera licenses this file to you under the Apache License, Version 2.0
7  (the "License"); you may not use this file except in compliance with the
8  License.  You may obtain a copy of the License at
9
10    http://www.apache.org/licenses/LICENSE-2.0
11
12  Unless required by applicable law or agreed to in writing, software
13  distributed under the License is distributed on an "AS IS" BASIS,
14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
15  implied.  See the License for the specific language governing
16  permissions and limitations under the License.
17
18 *****************************************************************************/
19
20/*****************************************************************************
21
22  test12.cpp --
23
24  Original Author: Martin Janssen, Synopsys, Inc., 2002-02-15
25
26 *****************************************************************************/
27
28/*****************************************************************************
29
30  MODIFICATION LOG - modifiers, enter your name, affiliation, date and
31  changes you are making here.
32
33      Name, Affiliation, Date:
34  Description of Modification:
35
36 *****************************************************************************/
37
38// test of next_trigger() for dynamic sensitivity; last call counts
39
40#include "systemc.h"
41
42SC_MODULE( mod_a )
43{
44    sc_event e1;
45    sc_event e2;
46    sc_event e3;
47    sc_event e_ack;
48
49    void write( const char* msg )
50    {
51        cout << sc_delta_count() << ":" << sc_time_stamp()
52             << " " << msg << "\n";
53    }
54
55    bool sender_first;
56
57    void sender()
58    {
59        next_trigger( SC_ZERO_TIME );
60        if( sender_first ) {
61            sender_first = false;
62            return;
63        }
64
65        e2.cancel();
66        e3.cancel();
67        e1.notify();
68        e2.notify( SC_ZERO_TIME );
69        e3.notify( 2, SC_NS );
70        timed_out() ? write( "sender - timed out" )
71                    : write( "sender" );
72        next_trigger( 3, SC_NS, e_ack );
73    }
74
75    int receiver_state;
76
77    void receiver()
78    {
79        sc_time t1( 1, SC_NS );
80
81        switch( receiver_state ) {
82	case 0:
83	    // test next_trigger(e)
84	    cout << "*** next_trigger(e)\n";
85
86	    next_trigger( e1 );
87	    break;
88	case 1:
89	    write( "receiver - e1" );
90	    e_ack.notify();
91	    next_trigger( e1 );
92	    next_trigger( e2 );
93	    break;
94	case 2:
95	    write( "receiver - e2" );
96	    e_ack.notify();
97	    next_trigger( e2 );
98	    next_trigger( e3 );
99	    break;
100	case 3:
101	    write( "receiver - e3" );
102	    e_ack.notify();
103
104	    // test next_trigger(or_list)
105	    cout << "*** next_trigger(or_list)\n";
106
107	    next_trigger( e3 );
108	    next_trigger( e1 | e1 | e1 );
109	    break;
110	case 4:
111	    write( "receiver - e1 | e1 | e1" );
112	    e_ack.notify();
113	    next_trigger( e1 | e1 | e1 );
114	    next_trigger( e2 | e2 | e2 );
115	    break;
116	case 5:
117	    write( "receiver - e2 | e2 | e2" );
118	    e_ack.notify();
119	    next_trigger( e2 | e2 | e2 );
120	    next_trigger( e3 | e3 | e3 );
121	    break;
122	case 6:
123	    write( "receiver - e3 | e3 | e3" );
124	    e_ack.notify();
125	    next_trigger( e3 | e3 | e3 );
126	    next_trigger( e1 | e2 | e3 );
127	    break;
128	case 7:
129	    write( "receiver - e1 | e2 | e3" );
130	    e_ack.notify();
131	    next_trigger( e1 | e2 | e3 );
132	    next_trigger( e3 | e2 | e1 );
133	    break;
134	case 8:
135	    write( "receiver - e3 | e2 | e1" );
136	    e_ack.notify();
137
138	    // test next_trigger(and_list)
139	    cout << "*** next_trigger(and_list)\n";
140
141	    next_trigger( e3 | e2 | e1 );
142	    next_trigger( e1 & e1 & e1 );
143	    break;
144	case 9:
145	    write( "receiver - e1 & e1 & e1" );
146	    e_ack.notify();
147	    next_trigger( e1 & e1 & e1 );
148	    next_trigger( e2 & e2 & e2 );
149	    break;
150	case 10:
151	    write( "receiver - e2 & e2 & e2" );
152	    e_ack.notify();
153	    next_trigger( e2 & e2 & e2 );
154	    next_trigger( e3 & e3 & e3 );
155	    break;
156	case 11:
157	    write( "receiver - e3 & e3 & e3" );
158	    e_ack.notify();
159	    next_trigger( e3 & e3 & e3 );
160	    next_trigger( e1 & e2 & e3 );
161	    break;
162	case 12:
163	    write( "receiver - e1 & e2 & e3" );
164	    e_ack.notify();
165	    next_trigger( e1 & e2 & e3 );
166	    next_trigger( e3 & e2 & e1 );
167	    break;
168	case 13:
169	    write( "receiver - e3 & e2 & e1" );
170
171	    // test next_trigger(t)
172	    cout << "*** next_trigger(t)\n";
173
174	    next_trigger( e3 & e2 & e1 );
175	    next_trigger( 0, SC_NS );
176	    break;
177	case 14:
178	    write( "receiver - 0 ns" );
179	    next_trigger( 0, SC_NS );
180	    next_trigger( 1, SC_NS );
181	    break;
182	case 15:
183	    write( "receiver - 1 ns" );
184
185	    e_ack.notify();
186
187	    // test next_trigger(t,e)
188	    cout << "*** next_trigger(t,e)\n";
189
190	    next_trigger( 1, SC_NS );
191	    next_trigger( 1, SC_NS, e1 );
192	    break;
193	case 16:
194	    timed_out() ? write( "receiver - 1 ns | e1 - timed out" )
195		        : write( "receiver - 1 ns | e1" );
196	    e_ack.notify();
197	    next_trigger( 1, SC_NS, e1 );
198	    next_trigger( t1, e2 );
199	    break;
200	case 17:
201	    timed_out() ? write( "receiver - 1 ns | e2 - timed out" )
202                        : write( "receiver - 1 ns | e2" );
203	    e_ack.notify();
204	    next_trigger( t1, e2 );
205	    next_trigger( 1, SC_NS, e3 );
206	    break;
207	case 18:
208	    timed_out() ? write( "receiver - 1 ns | e3 - timed out" )
209		        : write( "receiver - 1 ns | e3" );
210	    e_ack.notify();
211
212	    // test next_trigger(t,or_list)
213	    cout << "*** next_trigger(t,or_list)\n";
214
215	    next_trigger( 1, SC_NS, e3 );
216	    next_trigger( t1, e1 | e2 | e3 );
217	    break;
218	case 19:
219	    timed_out() ? write( "receiver - 1 ns | e1 | e2 | e3 - timed out" )
220                        : write( "receiver - 1 ns | e1 | e2 | e3" );
221	    e_ack.notify();
222
223	    // test next_trigger(t,and_list)
224	    cout << "*** next_trigger(t,and_list)\n";
225
226	    next_trigger( t1, e1 | e2 | e3 );
227	    next_trigger( t1, e1 & e2 & e3 );
228	    break;
229	case 20:
230	    timed_out() ? write( "receiver - 1 ns | e1 & e2 & e3 - timed out" )
231                        : write( "receiver - 1 ns | e1 & e2 & e3" );
232
233	    sc_stop();
234	    write( "receiver - stop" );
235	    next_trigger( t1, e1 & e2 & e3 );
236	    next_trigger( SC_ZERO_TIME );
237	    break;
238	default:
239	    sc_assert( false );
240        }
241	receiver_state ++;
242    }
243
244    SC_CTOR( mod_a )
245    {
246        SC_METHOD( sender );
247        sender_first = true;
248        SC_METHOD( receiver );
249        receiver_state = 0;
250    }
251};
252
253int
254sc_main( int, char*[] )
255{
256    mod_a a( "a" );
257
258    sc_start();
259
260    return 0;
261}
262