OpenCores
URL https://opencores.org/ocsvn/an-fpga-implementation-of-low-latency-noc-based-mpsoc/an-fpga-implementation-of-low-latency-noc-based-mpsoc/trunk

Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

[/] [an-fpga-implementation-of-low-latency-noc-based-mpsoc/] [trunk/] [mpsoc/] [perl_gui/] [lib/] [perl/] [interface.pm] - Blame information for rev 16

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 16 alirezamon 
#!/usr/bin/perl -w -I ..
2 
###############################################################################
3 
#
4 
# File:         interface.pm
5 
#
6 
#
7 
###############################################################################
8 
use warnings;
9 
use strict;
10 
use intfc_gen;
11 
use Data::Dumper;
12 
 
13 
use Cwd;
14 
 
15 
 
16 
 
17 
package interface;
18 
 
19 
 
20 
 
21 
 
22 
 
23 
sub interface_new {
24 
    # be backwards compatible with non-OO call
25 
    my $class = ("ARRAY" eq ref $_[0]) ? "interface" : shift;
26 
    my $self;
27 
 
28 
 
29 
    $self = {};
30 
    $self->{plugs}        = {};
31 
    $self->{sockets}      = {};
32 
    $self->{categories}   = {};
33 
 
34 
 
35 
        my $dir = Cwd::getcwd();
36 
        my @files = glob "$dir/lib/interface/*.ITC";
37 
        for my $p (@files){
38 
                #print "$p\n";
39 
                #my $infc_gen = Storable::retrieve($p);
40 
        # Read
41 
        my  $infc_gen;
42 
        $infc_gen = eval { do $p };
43 
        # Might need "no strict;" before and "use strict;" after "do"
44 
        die "Error reading: $@" if $@;
45 
 
46 
        add_intfc($self,$infc_gen);
47 
        }
48 
 
49 
 
50 
    bless($self,$class);
51 
 
52 
 
53 
    return $self;
54 
}
55 
 
56 
 
57 
sub add_category{
58 
        my ($self,$category,$intfc_name,$info)=@_;
59 
        $self->{categories}{$category}{names}{$intfc_name}{info}=$info;
60 
 
61 
}
62 
 
63 
sub get_description{
64 
        my ($self,$category,$name)=@_;
65 
        my $info;
66 
        if(exists ($self->{categories}{$category}{names}{$name})){
67 
                $info= $self->{categories}{$category}{names}{$name}{info};
68 
        }
69 
        return $info;
70 
}
71 
 
72 
 
73 
sub add_plug{
74 
                my($self,$plug,$info,$category,$connection_num,$connect_to)=@_;
75 
                $self->{plugs}{$plug}={};
76 
                $self->{plugs}{$plug}{connection_num}=$connection_num;
77 
                $self->{plugs}{$plug}{connect_to}=$connect_to;
78 
                $self->{plugs}{$plug}{info}=$info;
79 
                $self->{plugs}{$plug}{category}=$category;
80 
}
81 
 
82 
sub get_plug{
83 
                my($self,$plug)=@_;
84 
                my ($connection_num,$connect_to,$info,$category);
85 
                if(exists ($self->{plugs}{$plug})){
86 
                        $connection_num =$self->{plugs}{$plug}{connection_num};
87 
                        $connect_to             =$self->{plugs}{$plug}{connect_to};
88 
                        $info                   =$self->{plugs}{$plug}{info};
89 
                        $category               =$self->{plugs}{$plug}{category};
90 
 
91 
                }
92 
                return ($connection_num,$connect_to,$info,$category);
93 
}
94 
 
95 
 
96 
 
97 
sub add_socket{
98 
                my($self,$socket,$info,$category,$connection_num,$connect_to)=@_;
99 
                $self->{sockets}{$socket}={};
100 
                $self->{sockets}{$socket}{connection_num}=$connection_num;
101 
                $self->{sockets}{$socket}{connect_to}=$connect_to;
102 
                $self->{sockets}{$socket}{info}=$info;
103 
                $self->{sockets}{$socket}{category}=$category;
104 
}
105 
 
106 
 
107 
sub get_socket{
108 
                my($self,$socket)=@_;
109 
                my ($connection_num,$connect_to,$info,$category);
110 
                if(exists ($self->{sockets}{$socket})){
111 
                        $connection_num =$self->{sockets}{$socket}{connection_num};
112 
                        $connect_to             =$self->{sockets}{$socket}{connect_to};
113 
                        $info                   =$self->{sockets}{$socket}{info};
114 
                        $category               =$self->{sockets}{$socket}{category}=$category;
115 
                }
116 
                return ($connection_num,$connect_to,$info,$category);
117 
}
118 
 
119 
 
120 
sub add_param_to_plug{
121 
                my($self,$interface,$param,$value)=@_;
122 
                $self->{plugs}{$interface}{parameters}{$param}=$value;
123 
 
124 
}
125 
 
126 
 
127 
sub add_param_to_socket{
128 
                my($self,$interface,$param,$value)=@_;
129 
                $self->{sockets}{$interface}{parameters}{$param}=$value;
130 
 
131 
}
132 
 
133 
 
134 
 
135 
sub add_port_to_plug{
136 
        my($self,$interface,$port,$range,$type,$outport_type,$connect)=@_;
137 
        $self->{plugs}{$interface}{ports}{$port}={};
138 
        $self->{plugs}{$interface}{ports}{$port}{range}=$range;
139 
        $self->{plugs}{$interface}{ports}{$port}{type}=$type;
140 
        $self->{plugs}{$interface}{ports}{$port}{outport_type}=$outport_type;
141 
        $self->{plugs}{$interface}{ports}{$port}{connect}=$connect;
142 
 
143 
}
144 
 
145 
 
146 
sub get_port_info_of_socket{
147 
        my($self,$socket,$port)=@_;
148 
        my($range,$type,$connect);
149 
        if(exists ($self->{sockets}{$socket}{ports}{$port})){
150 
                $range=$self->{sockets}{$socket}{ports}{$port}{range};
151 
                $type=$self->{sockets}{$socket}{ports}{$port}{type};
152 
                $connect=$self->{sockets}{$socket}{ports}{$port}{connect};
153 
        }
154 
        return ($range,$type,$connect);
155 
}
156 
 
157 
sub get_port_info_of_plug{
158 
        my($self,$plug,$port)=@_;
159 
        my($range,$type,$connect);
160 
        if(exists ($self->{plugs}{$plug}{ports}{$port})){
161 
                $range=$self->{plugs}{$plug}{ports}{$port}{range};
162 
                $type=$self->{plugs}{$plug}{ports}{$port}{type};
163 
                $connect=$self->{plugs}{$plug}{ports}{$port}{connect};
164 
        }
165 
        return ($range,$type,$connect);
166 
}
167 
 
168 
 
169 
sub add_port_to_socket{
170 
        my($self,$socket,$port,$range,$type,$outport_type,$connect)=@_;
171 
        $self->{sockets}{$socket}{ports}{$port}={};
172 
        $self->{sockets}{$socket}{ports}{$port}{range}=$range;
173 
        $self->{sockets}{$socket}{ports}{$port}{type}=$type;
174 
        $self->{sockets}{$socket}{ports}{$port}{outport_type}=$outport_type;
175 
        $self->{sockets}{$socket}{ports}{$port}{connect}=$connect;
176 
 
177 
}
178 
 
179 
 
180 
sub get_socket_port_list{
181 
        my($self,$socket)=@_;
182 
        my @ports;
183 
        if(exists ($self->{sockets}{$socket}{ports})){
184 
                foreach my $p(keys %{$self->{sockets}{$socket}{ports}}){
185 
                        push (@ports,$p);
186 
                }
187 
        }
188 
        return @ports;
189 
}
190 
 
191 
sub get_plug_port_list{
192 
        my($self,$plug)=@_;
193 
        my @ports;
194 
        if(exists ($self->{plugs}{$plug}{ports})){
195 
                foreach my $p(keys %{$self->{plugs}{$plug}{ports}}){
196 
                        push (@ports,$p);
197 
                }
198 
        }
199 
        return @ports;
200 
}
201 
 
202 
 
203 
 
204 
sub get_interfaces{
205 
        my $self=shift;
206 
        my @interfaces;
207 
        if(exists ($self->{plugs})){
208 
                foreach my $p (sort keys %{$self->{plugs}}){
209 
                        push (@interfaces,$p);
210 
                }
211 
        }
212 
        return @interfaces;
213 
 
214 
 
215 
}
216 
 
217 
sub get_categories{
218 
        my $self=shift;
219 
        my @categories;
220 
        if(exists ($self->{categories})){
221 
                foreach my $p (sort keys %{$self->{categories}}){
222 
                        push (@categories,$p);
223 
                }
224 
        }
225 
        return @categories;
226 
 
227 
}
228 
 
229 
sub get_intfcs_of_category{
230 
        my ($self,$category)=@_;
231 
        my @list;
232 
        if(exists ($self->{categories}{$category}{names})){
233 
                foreach my $p (sort keys %{$self->{categories}{$category}{names}}){
234 
                        push (@list,$p);
235 
                }
236 
 
237 
        }
238 
        return @list;
239 
}
240 
 
241 
 
242 
sub add_intfc{
243 
 
244 
        my ($self,$infc_gen) =@_;
245 
 
246 
        my $intfc_name=$infc_gen->intfc_get_interface_name();
247 
        my $connection_num=$infc_gen->intfc_get_connection_num();
248 
        my $intfc_type=$infc_gen->intfc_get_interface_type();
249 
        my $intfc_info=$infc_gen->intfc_get_description();
250 
        my $intfc_category=$infc_gen->intfc_get_category();
251 
 
252 
 
253 
        my(%types,%ranges,%names,%connect_types,%connect_ranges,%connect_names,%outport_types);
254 
 
255 
 
256 
        add_socket($self,$intfc_name,$intfc_info,$intfc_category,$connection_num,$intfc_name);
257 
        add_plug($self,$intfc_name,$intfc_info,$intfc_category,$connection_num,$intfc_name);
258 
 
259 
        add_category($self,$intfc_category,$intfc_name,$intfc_info);
260 
 
261 
 
262 
        $infc_gen->intfc_get_ports(\%types,\%ranges,\%names,\%connect_types,\%connect_ranges,\%connect_names,\%outport_types);
263 
        foreach my $id (sort keys %ranges){
264 
                        my $type=$types{$id};
265 
                        my $range=$ranges{$id};
266 
                        my $name=$names{$id};
267 
                        my $connect_type=$connect_types{$id};
268 
                        my $connect_range=$connect_ranges{$id};
269 
                        my $connect_name=$connect_names{$id};
270 
                        my $outport_type=$outport_types{$id};
271 
 
272 
                        if($intfc_type eq 'plug'){
273 
 
274 
                                 #my($self,$interface,$port,$range,$type,$outport_type)
275 
                                add_port_to_plug        ($self,$intfc_name,$name,$range,$type,$outport_type,$connect_name);
276 
                                #print "add_port_to_plug(\$self,$intfc_name,$name,$range,$type,,$outport_type);\n";
277 
                                add_port_to_socket      ($self,$intfc_name,$connect_name,$connect_range,$connect_type,$outport_type,$name);
278 
                                #print "add_port_to_socket(\$self,$connect_name,$connect_range,$connect_type);\n";
279 
                        }
280 
                        else{
281 
                                add_port_to_socket($self,$intfc_name,$name,$range,$type,$outport_type,$connect_name);
282 
                                add_port_to_plug($self,$intfc_name,$connect_name,$connect_range,$connect_type,$outport_type,$name);
283 
                        }
284 
        }
285 
 
286 
}
287 
 
288 
 
289 
 
290 
 
291 
 
292 
 
293 
 
294 
 
295 
 
296 
 
297 
1

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.