Merge branch 'rust-random'

Author: jhaye

Rust/Savina/src/concurrency/Banking.lf

@@ -55,7 +55,7 @@ reactor Teller(numAccounts:usize(1000), numBankings:usize(50000)) {
 
     preamble {=
         use std::collections::VecDeque;
-        use crate::pseudo_random::PseudoRandomGenerator;
+        use crate::pseudo_random::{PseudoRandomGenerator, RandomValue};
 
         type MessageQueue = VecDeque<CreditMessage>;
 
@@ -92,14 +92,16 @@ reactor Teller(numAccounts:usize(1000), numBankings:usize(50000)) {
             // src is lower than dest id to ensure there is never a deadlock
             // Note: this comment stems from the original Akka implementation and
             // is actually not needed in LF, since cycle free programs cannot deadlock
-            let src_account = (self.randomGen.gen_u32() as usize) % ((self.num_accounts / 10) * 8);
-            let mut loop_id = (self.randomGen.gen_u32() as usize) % (self.num_accounts - src_account);
+            let max_account = ((self.num_accounts / 10) * 8) as i64;
+            let src_account: usize = self.randomGen.next_in_range(0..max_account).into();
+            let max_loop_id = (self.num_accounts - src_account) as i64;
+            let mut loop_id: usize = self.randomGen.next_in_range(0..max_loop_id).into();
             if loop_id == 0 {
                 loop_id += 1;
             }
             let dest_account = src_account + loop_id;
 
-            let amount = (1.0 / ((self.randomGen.next() + 1) as f64)) * 1000.0;
+            let amount = <RandomValue as Into<f64>>::into(self.randomGen.next()) * 1000.0;
 
             info!("Send {} from {} to {}", amount, src_account, dest_account);
             self.messageQueues[src_account].push_back(

Rust/Savina/src/concurrency/BoundedBuffer.lf

@@ -126,21 +126,21 @@ reactor ProducerReactor(bank_index: usize(0), numItemsToProduce: usize(1000), pr
     =}
 
     preamble {=
-        use crate::pseudo_random::PseudoRandomGenerator;
+        use crate::pseudo_random::{PseudoRandomGenerator, RandomValue};
         use std::f64;
 
         pub fn process_item(cur_term: f64, cost: usize) -> f64 {
             let mut res = cur_term;
 
-            let mut random = PseudoRandomGenerator::from(cost as _);
+            let mut random = PseudoRandomGenerator::from(cost as i64);
             if(cost > 0) {
                 for i in 0..cost {
                     for j in 0..100 {
-                        res += ((random.next() as f64).abs() + 0.01).log(f64::consts::E);
+                        res += (<RandomValue as Into<f64>>::into(random.next()).abs() + 0.01).log(f64::consts::E);
                     }
                 }
             } else {
-                res += ((random.next() as f64).abs() + 0.01).log(f64::consts::E);
+                res += (<RandomValue as Into<f64>>::into(random.next()).abs() + 0.01).log(f64::consts::E);
             }
 
             res

Rust/Savina/src/concurrency/CigaretteSmoker.lf

@@ -32,7 +32,7 @@ reactor ArbiterReactor(num_rounds: usize(1000), num_smokers: usize(200)) {
     state num_rounds(num_rounds);
     state roundsSoFar: usize(0);
     state random: PseudoRandomGenerator({=
-        PseudoRandomGenerator::from((num_rounds * num_smokers) as u64)
+        PseudoRandomGenerator::from((num_rounds * num_smokers) as i64)
     =});
 
     input inStart: unit;
@@ -46,16 +46,16 @@ reactor ArbiterReactor(num_rounds: usize(1000), num_smokers: usize(200)) {
     reaction(inStart) -> chooseSmoker {=
         // reset local state
         self.roundsSoFar = 0;
-        self.random = PseudoRandomGenerator::from((self.num_rounds * self.num_smokers) as _);
+        self.random = PseudoRandomGenerator::from((self.num_rounds * self.num_smokers) as i64);
 
         // start excution
         ctx.schedule(chooseSmoker, Asap);
     =}
 
     reaction(chooseSmoker) -> startSmoking, chooseSmoker, stop {=
         // assume resources grabbed instantaneously and choose a random smoker to start smoking
-        let new_smoker_index = self.random.next() as usize % self.num_smokers;
-        let busy_wait_period = (self.random.next() % 1000 + 10) as _;
+        let new_smoker_index = *self.random.next() as usize % self.num_smokers;
+        let busy_wait_period = (*(self.random.next()) % 1000 + 10) as _;
         ctx.set(startSmoking.get(new_smoker_index), busy_wait_period);
 
         // no need to wait for feedback from the smoker, as it starts smoking (logically) instantaneously

Rust/Savina/src/concurrency/SortedList.lf

@@ -1,9 +1,9 @@
 /**
  * Copyright (C) 2020 TU Dresden
- * 
+ *
  * This benchmark is very similar to the concurrent Dictionary benchmark.
  * It only uses a sorted linked list instead of a dictionary.
- * 
+ *
  * @author Christian Menard
  * @author Hannes Klein
  * @author Johannes Hayeß
@@ -19,32 +19,32 @@ import BenchmarkRunner from "../lib/BenchmarkRunner.lf";
 
 reactor Manager(numWorkers: usize(20)) {
     state num_workers(numWorkers);
-    
+
     state numWorkersTerminated: usize(0);
-    
+
     input start: unit;
     output finished: unit;
-    
+
     input[numWorkers] workersFinished: unit;
 
     logical action finish: unit;
-    
+
     reaction(finish) -> finished {=
         ctx.set(finished, ());
     =}
-    
+
     reaction(workersFinished) -> finish {=
-        for (i, worker) in workersFinished.into_iter().enumerate() {
+        for worker in workersFinished.into_iter() {
             if ctx.is_present(&worker) {
                 self.numWorkersTerminated += 1;
-                
+
                 if self.numWorkersTerminated == self.num_workers {
                     ctx.schedule(finish, Asap);
                 }
             }
         }
     =}
-    
+
     reaction(start) {=
         // reset local state
         self.numWorkersTerminated = 0;
@@ -61,57 +61,57 @@ reactor Worker(
     state num_messages_per_worker(numMessagesPerWorker);
     state write_percentage(writePercentage);
     state size_percentage(sizePercentage);
-    
+
     state messageCount: usize(0);
     state random: PseudoRandomGenerator;
-    
+
     input doWork: unit;
     output finished: unit;
-    
+
     output request: Message;
     input response: i32;
-    
+
     preamble {=
         use crate::pseudo_random::PseudoRandomGenerator;
     =}
-    
+
     reaction(doWork, response) -> request, finished {=
         if ctx.is_present(doWork) {
             // reset local state
             self.messageCount = 0;
             self.random = PseudoRandomGenerator::from(
-                (self.bank_index + 
+                (self.bank_index +
                 self.num_messages_per_worker +
                 self.write_percentage +
-                self.size_percentage) as u64
+                self.size_percentage) as i64
             );
         }
-        
+
         if self.messageCount < self.num_messages_per_worker {
             self.messageCount += 1;
-            let num = self.random.gen_range(0..100) as usize;
-            
+            let num: usize = self.random.next_in_range(0..100).into();
+
             if num < self.size_percentage {
                 ctx.set(request, Message {mtype: AccessType::Size, value: -1});
             } else if num < (self.size_percentage + self.write_percentage) {
-                ctx.set(request, Message {mtype: AccessType::Write, value: self.random.next() as i32});
+                ctx.set(request, Message {mtype: AccessType::Write, value: self.random.next().into()});
             } else {
-                ctx.set(request, Message {mtype: AccessType::Contains, value: self.random.next() as i32});
+                ctx.set(request, Message {mtype: AccessType::Contains, value: self.random.next().into()});
             }
         } else {
             // signal that work is complete
             ctx.set(finished, ());
         }
     =}
-    
+
     preamble {=
         #[derive(Copy, Clone)]
         pub enum AccessType {
             Write,
             Size,
             Contains,
         }
-        
+
         #[derive(Copy, Clone)]
         pub struct Message {
             pub mtype: AccessType,
@@ -121,38 +121,38 @@ reactor Worker(
 }
 
 reactor SortedListImpl(numWorkers: usize(20)) {
-    
+
     state dataList: SortedLinkedList<isize>;
     state responsesToSend: Vec<i32>({= vec![-1; numWorkers] =}) ;
-    
+
     input printResult: unit;
     input[numWorkers] requests: Message;
     output[numWorkers] responses: i32;
-    
+
     logical action sendResponses: unit;
-    
+
     preamble {=
         use crate::reactors::worker::{Message, AccessType};
     =}
-    
+
     reaction(printResult) {=
         // check result
         println!("List Size = {}", self.dataList.len());
-        
+
         // reset local state
         self.dataList.clear();
     =}
-    
+
     reaction(sendResponses) -> responses {=
         for (i, response) in responses.into_iter().enumerate() {
             ctx.set(response, self.responsesToSend[i]);
             info!("Reply to worker {} with {}", i, self.responsesToSend[i]);
         }
     =}
-    
+
     reaction(requests) -> sendResponses {=
         ctx.schedule(sendResponses, Asap);
-        
+
         for (i, request) in requests.into_iter().enumerate() {
             let msg = ctx.get(&request).unwrap();
             match msg.mtype {
@@ -178,11 +178,11 @@ reactor SortedListImpl(numWorkers: usize(20)) {
             }
         }
     =}
-    
+
     preamble {=
         use std::collections::LinkedList;
         use std::cmp::{PartialEq, PartialOrd};
-        
+
         // Linked list sorted in ascending order.
         // We are using the standard library here for a linked list, instead of
         // directly porting the naive C++ implementation.
@@ -194,25 +194,25 @@ reactor SortedListImpl(numWorkers: usize(20)) {
         pub struct SortedLinkedList<T> {
             list: LinkedList<T>,
         }
-        
+
         impl <T: PartialEq + PartialOrd + Copy> SortedLinkedList<T> {
             pub fn new() -> Self {
                 SortedLinkedList::<T> {
                     list: LinkedList::<T>::new(),
                 }
             }
-            
+
             pub fn is_empty(&self) -> bool {
                 self.list.is_empty()
             }
-            
+
             pub fn add(&mut self, item: &T) {
                 if self.list.is_empty() {
                     self.list.push_back(*item);
                 } else if item < self.list.front().unwrap() {
-                    self.list.push_front(*item); 
+                    self.list.push_front(*item);
                 } else if self.list.back().unwrap() < item {
-                    self.list.push_back(*item);  
+                    self.list.push_back(*item);
                 } else {
                     for (i, ele) in self.list.iter().enumerate() {
                         if item < ele {
@@ -226,27 +226,27 @@ reactor SortedListImpl(numWorkers: usize(20)) {
                     }
                 }
             }
-            
+
             pub fn contains(&self, item: &T) -> bool {
                 self.list.contains(item)
             }
-            
+
             pub fn len(&self) -> usize {
-                self.list.len()            
+                self.list.len()
             }
-            
+
             pub fn clear(&mut self) {
                 self.list.clear();
             }
         }
-        
+
         impl <T: Default + PartialEq + PartialOrd + Copy> Default for SortedLinkedList<T> {
             fn default() -> Self {
                 SortedLinkedList::<T>::new()
             }
         }
     =}
-    
+
 }
 
 main reactor (numIterations: usize(12), numMessagesPerWorker: usize(8000), writePercentage: usize(10), sizePercentage:usize(1), numWorkers: usize(20)) {
@@ -255,13 +255,13 @@ main reactor (numIterations: usize(12), numMessagesPerWorker: usize(8000), write
     state write_percentage(writePercentage);
     state size_percentage(sizePercentage);
     state num_workers(numWorkers);
-    
+
     manager = new Manager(numWorkers=numWorkers);
     workers = new[numWorkers] Worker(numMessagesPerWorker=numMessagesPerWorker, writePercentage=writePercentage, sizePercentage=sizePercentage);
     sortedList = new SortedListImpl(numWorkers=numWorkers);
-    
+
     runner = new BenchmarkRunner(num_iterations=numIterations);
-        
+
     reaction(startup) {=
         print_benchmark_info("SortedListBenchmark");
         print_args!(
@@ -278,17 +278,16 @@ main reactor (numIterations: usize(12), numMessagesPerWorker: usize(8000), write
         );
         print_system_info();
     =}
-    
+
     (runner.start)+ -> manager.start, workers.doWork;
     manager.finished -> runner.finished;
     manager.finished -> sortedList.printResult;
-   
+
     workers.request -> sortedList.requests;
     sortedList.responses -> workers.response;
     workers.finished -> manager.workersFinished;
-    
+
     preamble {=
         use crate::{print_args,reactors::benchmark_runner::{print_system_info, print_benchmark_info}};
-    =}  
+    =}
 }
-