exec: trace barrier instructions

benchmarks/src/matrixmul.rs

@@ -1,7 +1,7 @@
 use gpucachesim::exec::{
     alloc,
     model::{Dim, MemorySpace},
-    tracegen::{TraceGenerator, Tracer},
+    tracegen::{self, TraceGenerator, Tracer},
     Kernel, ThreadBlock, ThreadIndex,
 };
 use num_traits::{Float, Zero};
@@ -255,8 +255,9 @@ where
         shared_mem_b: Mutex::new(shared_mem_b),
         num_rows,
     };
+    let options = tracegen::Options::default();
     let trace = tracer
-        .trace_kernel(grid_dim, block_dim, &mut kernel)
+        .trace_kernel(grid_dim, block_dim, &mut kernel, &options)
         .await?;
     Ok((tracer.commands().await, vec![trace]))
 }

benchmarks/src/pchase.rs

@@ -2,10 +2,9 @@
 
 use gpucachesim::exec::{
     alloc,
-    tracegen::{TraceGenerator, Tracer},
+    tracegen::{self, TraceGenerator, Tracer},
     Kernel, MemorySpace, ThreadBlock, ThreadIndex,
 };
-// use num_traits::{Float, Zero};
 
 use tokio::sync::Mutex;
 
@@ -119,8 +118,9 @@ pub async fn pchase(
     };
     let grid_size = 1;
     let block_size = 1;
+    let options = tracegen::Options::default();
     let trace = tracer
-        .trace_kernel(grid_size, block_size, &mut kernel)
+        .trace_kernel(grid_size, block_size, &mut kernel, &options)
         .await?;
     traces.push(trace);
     Ok((tracer.commands().await, traces))

benchmarks/src/simple_matrixmul.rs

@@ -1,7 +1,7 @@
 use gpucachesim::exec::{
     alloc,
     model::{Dim, MemorySpace},
-    tracegen::{TraceGenerator, Tracer},
+    tracegen::{self, TraceGenerator, Tracer},
     Kernel, ThreadBlock, ThreadIndex,
 };
 use num_traits::{Float, NumCast, Zero};
@@ -175,8 +175,9 @@ where
         n,
         p,
     };
+    let options = tracegen::Options::default();
     let trace = tracer
-        .trace_kernel(grid_dim, block_dim, &mut kernel)
+        .trace_kernel(grid_dim, block_dim, &mut kernel, &options)
         .await?;
     Ok((tracer.commands().await, vec![trace]))
 }

benchmarks/src/transpose.rs

@@ -2,7 +2,7 @@ use color_eyre::eyre;
 use gpucachesim::exec::{
     alloc,
     model::{Dim, MemorySpace},
-    tracegen::{TraceGenerator, Tracer},
+    tracegen::{self, TraceGenerator, Tracer},
     Kernel,
 };
 use num_traits::{Float, NumCast, Zero};
@@ -117,6 +117,7 @@ pub mod coalesced {
 
                 let tile_idx = (tid.thread_idx.y + i) * TILE_DIM + tid.thread_idx.x;
                 let mat_idx = index_in + i as usize * self.cols;
+                dbg!(mat_idx);
                 tiles[(tid, tile_idx as usize)] = dev_mat[(tid, mat_idx)];
                 i += BLOCK_ROWS;
             }
@@ -239,6 +240,7 @@ where
     Debug, Clone, Copy, Hash, strum::EnumString, PartialEq, Eq, PartialOrd, Ord, serde::Deserialize,
 )]
 #[serde(rename_all = "lowercase")]
+#[strum(ascii_case_insensitive)]
 pub enum Variant {
     Naive,
     Coalesced,
@@ -401,8 +403,11 @@ where
         rows,
         cols,
     };
+    // run once
     let mut result =
         transpose::<T, coalesced::Transpose<T>>(&tracer, rows, cols, &mut kernel).await?;
+
+    // run more times
     for _ in 0..repetitions {
         let (commands, traces) =
             transpose::<T, coalesced::Transpose<T>>(&tracer, rows, cols, &mut kernel).await?;
@@ -506,7 +511,12 @@ where
     assert!(grid_dim.y > 0);
     assert!(grid_dim.z > 0);
 
-    let trace = tracer.trace_kernel(grid_dim, block_dim, kernel).await?;
+    let options = tracegen::Options {
+        no_data_dependency: true,
+    };
+    let trace = tracer
+        .trace_kernel(grid_dim, block_dim, kernel, &options)
+        .await?;
     Ok((tracer.commands().await, vec![trace]))
 }
 

benchmarks/src/vectoradd.rs

@@ -1,4 +1,4 @@
-use gpucachesim::exec::tracegen::{TraceGenerator, Tracer};
+use gpucachesim::exec::tracegen::{self, TraceGenerator, Tracer};
 use gpucachesim::exec::{alloc, Kernel, MemorySpace, ThreadBlock, ThreadIndex};
 use num_traits::{Float, Zero};
 
@@ -123,8 +123,9 @@ where
         dev_result: Mutex::new(dev_result),
         n,
     };
+    let options = tracegen::Options::default();
     let trace = tracer
-        .trace_kernel(grid_size, BLOCK_SIZE, &mut kernel)
+        .trace_kernel(grid_size, BLOCK_SIZE, &mut kernel, &options)
         .await?;
     Ok((tracer.commands().await, vec![trace]))
 }

exec/src/cfg.rs

@@ -1,17 +1,17 @@
-use crate::model::{MemInstruction, ThreadInstruction};
+use crate::model::{Instruction, MemInstruction, ThreadInstruction};
 use petgraph::prelude::*;
 
 #[derive(Debug)]
 pub enum TraceNode {
     Branch {
         branch_id: usize,
         id: usize,
-        instructions: Vec<MemInstruction>,
+        instructions: Vec<Instruction>,
     },
     Reconverge {
         branch_id: usize,
         id: usize,
-        instructions: Vec<MemInstruction>,
+        instructions: Vec<Instruction>,
     },
 }
 
@@ -51,7 +51,7 @@ impl TraceNode {
 
     // #[inline]
     #[must_use]
-    pub fn instructions(&self) -> &[MemInstruction] {
+    pub fn instructions(&self) -> &[Instruction] {
         match self {
             Self::Branch { instructions, .. } | Self::Reconverge { instructions, .. } => {
                 instructions
@@ -240,7 +240,7 @@ pub fn build_control_flow_graph(
         instructions: vec![],
     });
     let mut last_thread_cfg_node_idx = thread_cfg_root_node_idx;
-    let mut current_instructions = Vec::new();
+    let mut current_instructions: Vec<Instruction> = Vec::new();
     let mut branch_taken: HashMap<usize, bool> = HashMap::new();
 
     let mut unique_node_ids: HashMap<usize, usize> = HashMap::new();
@@ -305,7 +305,10 @@ pub fn build_control_flow_graph(
                 *node_id += 1;
             }
             ThreadInstruction::Access(access) => {
-                current_instructions.push(access.clone());
+                current_instructions.push(Instruction::Memory(access.clone()));
+            }
+            ThreadInstruction::Barrier => {
+                current_instructions.push(Instruction::Barrier);
             }
         }
     }

exec/src/kernel.rs

@@ -9,6 +9,8 @@ pub struct ThreadBlock {
 
 impl ThreadBlock {
     pub async fn synchronize_threads(&self) {
+        let inst = model::ThreadInstruction::Barrier;
+        self.memory.push_thread_instruction(&self.thread_id, inst);
         self.barrier.wait().await;
     }
 

exec/src/model.rs

@@ -33,8 +33,8 @@ pub enum MemAccessKind {
     Store,
 }
 
-/// Warp instruction
-#[derive(Debug, Clone, Ord, PartialOrd)]
+/// Memory instruction
+#[derive(Debug, Clone, Hash, Ord, PartialOrd)]
 pub struct MemInstruction {
     pub mem_space: MemorySpace,
     pub kind: MemAccessKind,
@@ -58,10 +58,18 @@ impl PartialEq for MemInstruction {
     }
 }
 
-/// Warp instruction
+/// Instruction
+#[derive(Debug, Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
+pub enum Instruction {
+    Memory(MemInstruction),
+    Barrier,
+}
+
+/// Thread instruction
 #[derive(Debug, Clone, PartialOrd, Ord)]
 pub enum ThreadInstruction {
     Access(MemInstruction),
+    Barrier,
     Nop,
     Branch(usize),
     TookBranch(usize),