1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#include "booksim.hpp"
#include <assert.h>
#include "arbiter.hpp"
Arbiter::Arbiter( const Configuration &,
Module *parent, const string& name,
int inputs )
: Module( parent, name ), _inputs( inputs )
{
}
Arbiter::~Arbiter( )
{
}
void Arbiter::Clear( )
{
_requests.clear( );
}
void Arbiter::AddRequest( int in, int label, int pri )
{
sRequest r;
list<sRequest>::iterator insert_point;
r.in = in; r.label = label; r.pri = pri;
insert_point = _requests.begin( );
while ( ( insert_point != _requests.end( ) ) &&
( insert_point->in < in ) ) {
insert_point++;
}
bool del = false;
bool add = true;
// For consistant behavior, delete the existing request
// if it is for the same input and has a higher
// priority
if ( ( insert_point != _requests.end( ) ) &&
( insert_point->in == in ) ) {
if ( insert_point->pri < pri ) {
del = true;
} else {
add = false;
}
}
if ( add ) {
_requests.insert( insert_point, r );
}
if ( del ) {
_requests.erase( insert_point );
}
}
void Arbiter::RemoveRequest( int in, int label )
{
list<sRequest>::iterator erase_point;
erase_point = _requests.begin( );
while ( ( erase_point != _requests.end( ) ) &&
( erase_point->in < in ) ) {
erase_point++;
}
assert( erase_point != _requests.end( ) );
_requests.erase( erase_point );
}
int Arbiter::Match( ) const
{
return _match;
}
//==================================================
// PriorityArbiter
//==================================================
PriorityArbiter::PriorityArbiter( const Configuration &config,
Module *parent, const string& name,
int inputs )
: Arbiter( config, parent, name, inputs )
{
_rr_ptr = 0;
}
PriorityArbiter::~PriorityArbiter( )
{
}
void PriorityArbiter::Arbitrate( )
{
list<sRequest>::iterator p;
int max_index, max_pri;
bool wrapped;
if ( _requests.begin( ) != _requests.end( ) ) {
// A round-robin arbiter between input requests
p = _requests.begin( );
while ( ( p != _requests.end( ) ) &&
( p->in < _rr_ptr ) ) {
p++;
}
max_index = -1;
max_pri = 0;
wrapped = false;
while ( (!wrapped) || ( p->in < _rr_ptr ) ) {
if ( p == _requests.end( ) ) {
if ( wrapped ) {
break;
}
// p is valid here because empty lists
// are skipped (above)
p = _requests.begin( );
wrapped = true;
}
// check if request is the highest priority so far
if ( ( p->pri > max_pri ) || ( max_index == -1 ) ) {
max_pri = p->pri;
max_index = p->in;
}
p++;
}
_match = max_index; // -1 for no match
if ( _match != -1 ) {
_rr_ptr = ( _match + 1 ) % _inputs;
}
} else {
_match = -1;
}
}
|
