Differences

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

--- intro_example:pure_struct [2025/05/01 15:30] – rajit
+++ intro_example:pure_struct [2025/05/18 15:07] (current) – rajit
@@ Line 1: / Line 1: @@
 ====== Using pure structures ======
-A pure structure is a user-defined data type that contains only ''int''/''bool'' or other pure structures. An example of a pure structure is:
+A [[language:types2:data#pure_structures|pure structure]] is a user-defined data type that contains only ''int''/''bool'' or other pure structures. Pure structures are analogous to C/C++ ''struct''s, and can be used to organize data and
+make CHP more human-readable. An example of a pure structure is:
 <code act>
@@ Line 10: / Line 11: @@
 <code act>
-defproc cache(chan?(int<32>) A; chan?(bool) RD; chan!(int<32>) DI; out!(int<32>) DO)
+defproc cache(chan?(int<32>) A; chan?(bool) RD; chan!(int<32>) DI; chan!(int<32>) DO)
 {
    cache_entry C[256];
@@ Line 20: / Line 21: @@
      *[ A?addr,RD?cmd;
         [cmd -> // read command
-                       ce := C[addr{7..0}];
+              ce := C[addr{7..0}];
-                     [ ce.valid & ce.tag = addr{31..8} -> log ("cache hit!"); DO!ce.data
+             [ ce.valid & ce.tag = addr{31..8} -> log ("cache hit!"); DO!ce.data
-                     [] else -> log ("cache miss!"); DO!0
+             [] else -> log ("cache miss!"); DO!0
-                     ]
+             ]
-     []~cmd -> // write command
+        []~cmd -> // write command
-                  ce.valid+;
+             ce.valid+;
-                  DI?ce.data;
+             DI?ce.data;
-                  ce.tag := addr{31..8}
+             ce.tag := addr{31..8};
-                  C[addr{7..0}] := ce
+             C[addr{7..0}] := ce
       ]
    ]
@@ Line 35: / Line 36: @@
 </code>
+(Note: this is not meant to be a working cache!)
+===== Methods =====
+We can abstract away the matching function as follows:
+<code act>
+deftype cache_entry (bool valid; int<32> data; int<24> tag)
+{
+    methods {
+        function match (int<32> addr) : bool
+        {
+           chp {
+              self := valid & tag = addr{31..8}
+           }
+         }
+    }
+}
+defproc cache(chan?(int<32>) A; chan?(bool) RD; chan?(int<32>) DI; chan!(int<32>) DO)
+{
+   cache_entry C[256];
+   int<32> addr;
+   bool cmd;
+   cache_entry ce;
+   chp {
+     *[ A?addr,RD?cmd;
+        [cmd -> // read command
+              ce := C[addr{7..0}];
+             [ ce.match(addr) -> log ("cache hit!"); DO!ce.data
+             [] else -> log ("cache miss!"); DO!0
+             ]
+       []~cmd -> // write command
+             ce.valid+;
+             DI?ce.data;
+             ce.tag := addr{31..8};
+             C[addr{7..0}] := ce
+      ]
+   ]
+  }
+}
+</code>
+Note that method functions, like other functions in ACT, are pure functions. In other words, they cannot change the fields of the structure. If you need to modify the fields of the structure, special ''macro'' methods are supported. These can contain arbitrary CHP fragments.
+<code act>
+deftype cache_entry (bool valid; int<32> data; int<24> tag)
+{
+    methods {
+        function match (int<32> addr) : bool
+        {
+           chp {
+              self := valid & tag = addr{31..8}
+           }
+         }
+         macro setval (int<32> addr; int<32> dv) {
+            valid+;
+            data := dv;
+            tag := addr{31..8}
+         }
+    }
+}
+defproc cache(chan?(int<32>) A; chan?(bool) RD; chan?(int<32>) DI; chan!(int<32>) DO)
+{
+   cache_entry C[256];
+   int<32> addr, dv;
+   bool cmd;
+   cache_entry ce;
+   chp {
+     *[ A?addr,RD?cmd;
+        [cmd -> // read command
+              ce := C[addr{7..0}];
+             [ ce.match(addr) -> log ("cache hit!"); DO!ce.data
+             [] else -> log ("cache miss!"); DO!0
+             ]
+       []~cmd -> // write command
+             DI?dv;
+             ce.setval (addr, dv);
+             C[addr{7..0}] := ce
+      ]
+   ]
+  }
+}
+</code>
+===== Converting to raw integers =====
+A common requirement is to convert a pure structure data type into a collection of bits, corresponding to an integer with a bit-width that is the sum of the widths of all the elements within the pure structure.
+In the example above, this can be done as follows:
+<code act>
+int<57> x;
+...
+chp {
+   ...;
+   x := int(ce);
+   ...
+   ce := cache_type(x);
+   ...
+}
+</code>
+The order in which the bits are packed is from left to right in the structure definition, with the left-most field corresponding to the most significant bits of the integer.