Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision 		Previous revision
language:introduction [2019/04/18 11:02]
rajit [Namespaces] 		language:introduction [2022/05/13 08:31] (current)
rajit
Line 16: Line 16:
 To get a feel for how a circuit is described in ACT, we begin with a simple example circuit. The purpose of this circuit is to create a dual rail channel (called ''a1of2'' for a one-of-two encoded data channel and an acknowledge) and attach a bit-bucket to it. To get a feel for how a circuit is described in ACT, we begin with a simple example circuit. The purpose of this circuit is to create a dual rail channel (called ''a1of2'' for a one-of-two encoded data channel and an acknowledge) and attach a bit-bucket to it.
  
-<code>+<code act>
 /* my first act program */ /* my first act program */
 defchan a1of2 <: chan(bool) (bool d0,d1,a) defchan a1of2 <: chan(bool) (bool d0,d1,a)
Line 72: Line 72:
 legal: legal:
  
-<code>+<code act>
 bitbucket b; bitbucket b;
 a1of2 x1; a1of2 x1;
Line 81: Line 81:
 On the other hand, the following declaration is incorrect. On the other hand, the following declaration is incorrect.
  
-<code>+<code act>
 pbool 5; pbool 5;
 +</code>
 +<code>
 -[ERROR]-> Expecting bnf-item `instance_id', got `5' -[ERROR]-> Expecting bnf-item `instance_id', got `5'
 </code> </code>
Line 96: Line 98:
 consider the following definition of ''bitbucket''. consider the following definition of ''bitbucket''.
  
-<code>+<code act>
 defproc bitbucket(a1of2 d) defproc bitbucket(a1of2 d)
 { {
Line 112: Line 114:
 result in the following message: result in the following message:
  
-<code>+<code act>
 bitbucket b; bitbucket b;
 a1of2 c; a1of2 c;
 b.p = c.d0; b.p = c.d0;
 +</code>
 +<code>
 -[ERROR]-> `p' is not a port for `bitbucket' -[ERROR]-> `p' is not a port for `bitbucket'
 </code> </code>
Line 137: Line 141:
  
 Most circuits contain a set of components that are replicated a number Most circuits contain a set of components that are replicated a number
-of times. This is especially common in datapath circuits. @sc{act} has a+of times. This is especially common in datapath circuits. ACT has a
 very flexible array mechanism that can be used to construct complex very flexible array mechanism that can be used to construct complex
 circuits. The simplest way to create an array is shown below. circuits. The simplest way to create an array is shown below.
  
-<code>+<code act>
 bool x[10]; bool x[10];
 a1of2 y[5][3]; a1of2 y[5][3];
Line 153: Line 157:
 be specified as shown below be specified as shown below
  
-<code>+<code act>
 bool w[4..7]; // create Booleans w[4], ..., w[7] bool w[4..7]; // create Booleans w[4], ..., w[7]
 </code> </code>
Line 162: Line 166:
 block. Consider the following instantiation: block. Consider the following instantiation:
  
-<code>+<code act>
 bool x[10]; bool x[10];
 bool x[12..14]; bool x[12..14];
Line 172: Line 176:
 following, on the other hand, is not valid. following, on the other hand, is not valid.
  
-<code>+<code act>
 bool x[10]; bool x[10];
 bool x[9..14]; bool x[9..14];
 -[ERROR]-> Sparse array: overlap in range in instantiation -[ERROR]-> Sparse array: overlap in range in instantiation
-           Oiginal: [10]; adding: [9..14]+           Original: [10]; adding: [9..14]
 </code> </code>
 Each index of an array can only be created once. Each index of an array can only be created once.
Line 189: Line 193:
 below. below.
  
-<code>+<code act>
 bool x[10]; bool x[10];
 bool x[12..14]; bool x[12..14];
Line 203: Line 207:
 succeed, and their shapes also have to be compatible. succeed, and their shapes also have to be compatible.
  
-<code>+<code act>
 bool x[12]; bool x[12];
 bool w[4][3]; bool w[4][3];
 x=w; x=w;
 +</code>
 +<code>
 -[ERROR]-> Type-checking failed in connection -[ERROR]-> Type-checking failed in connection
            Types `bool[12]' and `bool[4][3]' are not compatible            Types `bool[12]' and `bool[4][3]' are not compatible
Line 213: Line 219:
 The following are examples of valid connections: The following are examples of valid connections:
  
-<code>+<code act>
 bool x[10]; bool x[10];
 bool x[10..12]; bool x[10..12];
Line 233: Line 239:
 carry chain for a ten bit ripple-carry adder. carry chain for a ten bit ripple-carry adder.
  
-<code>+<code act>
 fulladder fa[10]; fulladder fa[10];
 (i : 9 : fa[i].co=fa[i+1].ci; ) (i : 9 : fa[i].co=fa[i+1].ci; )
Line 251: Line 257:
 indices are connected to ''z''. indices are connected to ''z''.
  
-<code>+<code act>
 bool x[10], y[10], z[10]; bool x[10], y[10], z[10];
  
Line 282: Line 288:
 instance, ACT files will tend to begin with instance, ACT files will tend to begin with
  
-<code>+<code act>
 bool Reset,Reset_; bool Reset,Reset_;
 </code> </code>
Line 304: Line 310:
 within the namespace. within the namespace.
  
-<code>+<code act>
 namespace lib { namespace lib {
   export defchan a1of2 <: chan(bool) (bool d0,d1,a) { ... }   export defchan a1of2 <: chan(bool) (bool d0,d1,a) { ... }
Line 327: Line 333:
 Namespaces can be nested. For instance, we could have: Namespaces can be nested. For instance, we could have:
  
-<code>+<code act>
 namespace processor { namespace processor {
  
   namespace lib {   namespace lib {
-       export defchan a1of2 = chan(bool) (bool d0,d1,a) { ... } +       export defchan a1of2 <: chan(bool) (bool d0,d1,a) { ... } 
   }   }
  
Line 345: Line 351:
 ''processor'' namespace. ''processor'' namespace.
  
-<code>+<code act>
 namespace processor { namespace processor {
  
   namespace lib {   namespace lib {
-       export defchan a1of2 = chan(bool) (bool d0,d1,a) { ... }+       export defchan a1of2 <: chan(bool) (bool d0,d1,a) { ... }
   }   }
  
Line 355: Line 361:
  
 processor::lib::a1of2 d; processor::lib::a1of2 d;
 +</code>
 +<code>
 -[ERROR]-> Type is not exported up the namespace hierarchy: -[ERROR]-> Type is not exported up the namespace hierarchy:
            processor::lib::a1of2            processor::lib::a1of2
Line 363: Line 371:
 exporting the namespace itself. exporting the namespace itself.
  
-<code>+<code act>
 namespace processor { namespace processor {
  
   export namespace lib {   export namespace lib {
-       export defchan a1of2 = chan(bool) (bool d0,d1,a) { ... }+       export defchan a1of2 <: chan(bool) (bool d0,d1,a) { ... }
   }   }
  
Line 402: Line 410:
 ''import'' to include type definitions defined elsewhere. ''import'' to include type definitions defined elsewhere.
  
-<code>+<code act>
 import "channel.act"; import "channel.act";
 ... ...
Line 424: Line 432:
 the namespaces, and could create naming conflicts (e.g. multiple the namespaces, and could create naming conflicts (e.g. multiple
 definition of types having the same name---an error). To solve this definition of types having the same name---an error). To solve this
-problem, one can do the following:+problem, one can do the following: 
  
-<code>+<code act>
 import "lib1.act"; import "lib1.act";
 open lib -> lib1; open lib -> lib1;
Line 446: Line 454:
 because not all types might be exported! In this case we can say: because not all types might be exported! In this case we can say:
  
-<code>+<code act>
 import "lib.act"; import "lib.act";
 open processor::lib; open processor::lib;
Line 467: Line 475:
 hierarchy. The import statement hierarchy. The import statement
  
-<code>+<code act>
 import processor::lib; import processor::lib;
 </code> </code>
Line 473: Line 481:
 is equivalent to the following: is equivalent to the following:
  
-<code>+<code act>
 import "processor/lib/_all_.act"; import "processor/lib/_all_.act";
 </code> </code>
language/introduction.1555599724.txt.gz · Last modified: 2020/12/02 01:00 (external edit)
Except where otherwise noted, content on this wiki is licensed under the following license: GNU Free Documentation License 1.3


  • Show page
  • Old revisions
  • Backlinks
  • Recent Changes
  • Media Manager
  • Sitemap