sc_process_handle_less_than.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// sc_process_handle_less_than.cpp -- test for
21//
22//  Original Author: John Aynsley, Doulos, Inc.
23//
24// MODIFICATION LOG - modifiers, enter your name, affiliation, date and
25//
26// $Log: sc_process_handle_less_than.cpp,v $
27// Revision 1.2  2011/05/08 19:18:46  acg
28//  Andy Goodrich: remove extraneous + prefixes from git diff.
29//
30
31// sc_process_handle::operator< and swap
32
33#define SC_INCLUDE_DYNAMIC_PROCESSES
34
35#include <systemc>
36#include <map>
37
38using namespace sc_core;
39using std::cout;
40using std::endl;
41
42struct Top: sc_module
43{
44  Top(sc_module_name _name)
45  {
46    SC_THREAD(T1);
47    SC_THREAD(T2);
48  }
49
50  void T1()
51  {
52    sc_process_handle a, b;                // Two empty handles
53    sc_assert( !a.valid() && !b.valid() ); // Both are invalid
54    sc_assert( a != b );
55    sc_assert( !(a < b) && !(b < a) );
56
57    a = sc_spawn(sc_bind(&Top::f, this));
58    b = sc_spawn(sc_bind(&Top::f, this));
59
60    sc_assert( a != b );
61    sc_assert( (a < b) || (b < a) );       // Two handles to different processes
62
63    sc_process_handle c = b;
64
65    sc_assert( b == c );
66    sc_assert( !(b < c) && !(c < b) );     // Two handles to the same process
67
68    std::map<sc_process_handle, int> m;
69    m[a] = 1;
70    m[b] = 2;
71    m[c] = 3;
72
73    sc_assert( m.size() == 2 );
74    sc_assert( m[a] == 1 );
75    sc_assert( m[b] == 3 );
76    sc_assert( m[c] == 3 );
77
78    a.swap(b);
79    sc_assert( m[a] == 3 );
80    sc_assert( m[b] == 1 );
81    sc_assert( m[c] == 3 );
82    b.swap(a);
83
84    wait( a.terminated_event() & b.terminated_event() );
85
86    sc_assert( (a < b) || (b < a) ); // Same ordering whether handles are valid or not
87
88    if ( b.valid() ) // Handles may or may not have been invalidated
89      sc_assert( b == c );
90    else
91      sc_assert( b != c );
92
93    sc_assert( b.valid() == c.valid() ); // Invalidation is consistent
94    sc_assert( !(b < c) && !(c < b) ); // Two handles to the same process, whether valid or not
95    sc_assert( c.terminated() );
96
97    sc_process_handle d = a;
98    m[d] = 4;
99
100    sc_assert( m.size() == 2 );
101    sc_assert( m[a] == 4 );
102    sc_assert( m[b] == 3 );
103    sc_assert( m[c] == 3 );
104    sc_assert( m[d] == 4 );
105
106    sc_process_handle e;
107    m[e] = 5;
108
109    sc_assert( m.size() == 3 );
110    sc_assert( m[a] == 4 );
111    sc_assert( m[b] == 3 );
112    sc_assert( m[c] == 3 );
113    sc_assert( m[d] == 4 );
114    sc_assert( m[e] == 5 );
115
116    sc_process_handle f;
117    m[f] = 6;
118
119    sc_assert( m.size() == 3 );
120    sc_assert( m[a] == 4 );
121    sc_assert( m[b] == 3 );
122    sc_assert( m[c] == 3 );
123    sc_assert( m[d] == 4 );
124    sc_assert( m[e] == 6 );
125    sc_assert( m[f] == 6 );
126
127    sc_process_handle g;
128    m[g] = 7;
129
130    sc_assert( m.size() == 3 );
131    sc_assert( m[a] == 4 );
132    sc_assert( m[b] == 3 );
133    sc_assert( m[c] == 3 );
134    sc_assert( m[d] == 4 );
135    sc_assert( m[e] == 7 );
136    sc_assert( m[f] == 7 );
137    sc_assert( m[g] == 7 );
138
139    g = sc_spawn(sc_bind(&Top::f, this));
140    m[g] = 8;
141
142    sc_assert( m.size() == 4 );
143    sc_assert( m[a] == 4 );
144    sc_assert( m[b] == 3 );
145    sc_assert( m[c] == 3 );
146    sc_assert( m[d] == 4 );
147    sc_assert( m[e] == 7 );
148    sc_assert( m[f] == 7 );
149    sc_assert( m[g] == 8 );
150
151    cout << "T1 completed" << endl;
152  }
153
154  void T2()
155  {
156    sc_process_handle a, b = sc_get_current_process_handle();
157    sc_assert( b.valid() );
158
159    a.swap( b );
160    sc_assert( a == sc_get_current_process_handle() );
161    sc_assert( !b.valid() );
162
163    cout << "T2 completed" << endl;
164  }
165
166  void f() {}
167
168  SC_HAS_PROCESS(Top);
169};
170
171int sc_main(int argc, char* argv[])
172{
173  Top top("top");
174
175  sc_start();
176
177  cout << endl << "Success" << endl;
178  return 0;
179}
180
181