1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

use ferrite_session::prelude::*;
use futures::future::join_all;
use ipc_channel::ipc;

define_choice! { CounterCommand;
  Increment: Release,
  GetCount: SendValue < u64, Release >,
}

type CounterSession = LinearToShared<ExternalChoice<CounterCommand>>;

fn make_counter_session(count: u64) -> SharedSession<CounterSession>
{
  accept_shared_session(async move {
    offer_choice! {
      Increment => {
        println!("provider incrementing count {}", count);

          detach_shared_session (
            make_counter_session ( count + 1 )
          )
      }
      GetCount => {
        println!("provider sending back count {}", count);
        send_value ( count,
            detach_shared_session (
              make_counter_session ( count ) ) )
      }
    }
  })
}

async fn use_counter(
  counter: SharedChannel<CounterSession>,
  count: u64,
) -> u64
{
  let mut futures = vec![];

  for i in 0..count {
    let future = async_acquire_shared_session(counter.clone(), move |chan| {
      choose!(
        chan,
        Increment,
        step(async move {
          println!("client incremented counter");
          release_shared_session(chan, terminate())
        })
      )
    });

    futures.push(future);

    if i % 1000 == 0 {
      join_all(futures.drain(0..)).await;
    }
  }

  join_all(futures).await;

  run_session_with_result(acquire_shared_session(counter, |chan| {
    choose!(
      chan,
      GetCount,
      receive_value_from(chan, move |count| release_shared_session(
        chan,
        send_value(count, terminate())
      ))
    )
  }))
  .await
}

#[tokio::main]

pub async fn main()
{
  env_logger::init();

  let counter = run_shared_session(make_counter_session(0));

  let (sender, receiver) = ipc::channel().unwrap();

  sender.send(counter).unwrap();

  let shared = receiver.recv().unwrap();

  // let shared = counter.clone();

  let count = use_counter(shared, 10000).await;

  println!("count: {}", count);
}