Execution Time

[dolglao]

I was playing with the library and noticed an absurd difference between the execution time in the code in rust and in the desktop.
Could you help me understand why?

CODE

use colored::*;
use postflop_solver::*;
use std::time::Instant;

fn str_to_action(s: &str, previous_action: Option<&Action>) -> Action {
    match s {
        "X" => Action::Check,
        "C" => Action::Call,
        "F" => Action::Fold,
        action if action.starts_with("R") => {
            let amount = action[1..].parse::<i32>().unwrap();
            match previous_action {
                Some(Action::Bet(_)) | Some(Action::Raise(_)) => Action::Raise(amount),
                _ => Action::Bet(amount),
            }
        }
        _ => panic!("Action not recognized: {}", s),
    }
}

fn main() {
    //initialStartingPot, initialEffectiveStack, oopRangeString, ipRangeString, comuniteCards, myCards, ACTIONS

    // ranges of OOP and IP in string format
    let initial_pot = 2;
    let initial_effective_stack = 25;
    let oop_range = "A6s:0.449,A5s:0.7827,A4s:0.9752,A3s:0.9311,A2s:0.9765,A5o:0.0538,A4o:0.2401,A3o:0.8867,A2o:0.3575,KTs:0.2043,K9s:0.8909,K8s:0.9976,K7s:0.9998,K6s-K2s,KJo:0.1562,KTo:0.5317,K9o:0.2828,K8o:0.4636,K7o:0.6989,K6o:0.6578,K5o:0.6855,K4o:0.858,K3o,K2o:0.9969,QTs:0.6085,Q9s:0.995,Q8s:0.9842,Q7s-Q2s,QJo:0.5404,QTo:0.5559,Q9o:0.5067,Q8o:0.6196,Q7o:0.7465,Q6o:0.5897,Q5o:0.6388,Q4o:0.9382,Q3o:0.9658,Q2o:0.8275,JTs:0.001,J9s:0.9537,J8s:0.9997,J7s-J5s,J4s:0.9976,J3s-J2s,JTo:0.7487,J9o:0.6725,J8o:0.7398,J7o:0.7507,J6o:0.9026,J5o:0.8723,J4o:0.9196,J3o:0.9375,J2o:0.605,T9s:0.0211,T8s:0.5222,T7s:0.9999,T6s:0.9596,T5s:0.9756,T4s:0.9989,T3s:0.8984,T2s:0.7132,T9o:0.7732,T8o:0.7646,T7o:0.6773,T6o:0.7639,T5o:0.9903,T4o:0.9359,T3o:0.9282,T2o:0.6008,98s:0.1334,97s:0.8901,96s:0.4972,95s:0.7598,94s,93s:0.992,92s:0.6987,98o:0.8678,97o:0.7685,96o:0.8097,95o:0.8017,94o:0.9889,93o:0.9476,92o:0.6706,87s:0.6148,86s:0.4815,85s:0.9736,84s:0.9067,83s:0.9937,82s:0.9115,87o:0.7236,86o:0.8185,85o:0.7275,84o:0.7811,83o:0.8142,82o:0.5615,76s:0.0838,75s:0.9417,74s:0.8575,73s:0.6634,72s:0.9989,76o:0.7532,75o:0.8041,74o:0.7983,73o:0.8878,72o:0.3878,65s:0.0014,64s:0.8416,63s:0.7423,62s:0.76,65o:0.8738,64o:0.8231,63o:0.8287,62o:0.8123,54s:0.3705,53s:0.8828,52s:0.9587,54o:0.8891,53o:0.9086,52o:0.7582,43s:0.6601,42s:0.9037,43o:0.9023,42o:0.8367,32s:0.5141,32o:0.887";
    let ip_range = "KK:0.0536,QQ:0.3296,JJ:0.4401,TT:0.3427,99:0.3491,88:0.363,77:0.4156,66:0.6289,55:0.501,44:0.5905,33:0.6576,22:0.6113,AKs:0.0056,AQs:0.0113,AJs:0.0143,ATs:0.0022,A9s:0.4383,A8s:0.334,A7s:0.3721,A6s:0.3712,A5s:0.8207,A4s:0.7268,A3s:0.6959,A2s:0.8414,AKo:0.2601,AQo:0.4569,AJo:0.6602,ATo:0.8457,A9o:0.7107,A8o:0.8016,A7o:0.7067,A6o:0.4037,A5o:0.3111,A4o:0.5217,A3o:0.6797,A2o:0.8445,KQs:0.4548,KJs:0.5832,KTs:0.1179,K9s:0.4688,K8s:0.6795,K7s:0.5364,K6s:0.7579,K5s:0.3515,K4s:0.8199,K3s:0.778,K2s:0.9973,KQo:0.542,KJo:0.4478,KTo:0.6224,K9o:0.4821,K8o:0.322,K7o:0.4711,K6o:0.4229,K5o:0.5305,K4o:0.679,K3o:0.8166,K2o:0.9885,QJs:0.7541,QTs:0.6957,Q9s:0.971,Q8s:0.6316,Q7s:0.4829,Q6s:0.534,Q5s:0.8104,Q4s:0.9236,Q3s:0.9941,Q2s:0.882,QJo:0.3983,QTo:0.5236,Q9o:0.4215,Q8o:0.4118,Q7o:0.4069,Q6o:0.4581,Q5o:0.4721,Q4o:0.7237,Q3o:0.9515,Q2o,JTs:0.2167,J9s:0.8309,J8s:0.7976,J7s:0.7303,J6s:0.8962,J5s:0.8032,J4s:0.7668,J3s:0.7804,J2s:0.4598,JTo:0.6602,J9o:0.5128,J8o:0.424,J7o:0.4549,J6o:0.6241,J5o:0.7199,J4o:0.8173,J3o:0.87,J2o,T9s:0.6395,T8s:0.667,T7s:0.7504,T6s:0.9318,T5s:0.5248,T4s:0.3357,T3s:0.0657,T2s:0.0012,T9o:0.5553,T8o:0.5116,T7o:0.4521,T6o:0.5903,T5o:0.9097,T4o:0.867,T3o:0.9995,T2o:0.9999,98s:0.7336,97s:0.7951,96s:0.8036,95s:0.4974,94s:0.001,93s:0.0024,92s:0.0051,98o:0.5627,97o:0.505,96o:0.6013,95o:0.82,94o,93o:0.9997,92o:0.9879,87s:0.7327,86s:0.6663,85s:0.4463,84s:0.0223,83s:0.2223,82s:0.6956,87o:0.608,86o:0.6776,85o:0.844,84o,83o:0.3736,82o:0.0344,76s:0.7467,75s:0.6866,74s:0.2947,73s:0.001,72s:0.997,76o:0.656,75o:0.6615,74o:0.9997,73o:0.9978,65s:0.7531,64s:0.5853,63s:0.3994,62s:0.5066,65o:0.5718,64o:0.757,63o:0.9999,54s:0.5788,53s:0.7812,52s:0.3237,54o:0.64,53o:0.7097,52o:0.9902,43s:0.5094,42s:0.4773,43o:0.8913,32s:0.6406";
    let communite_cards = ["2d", "7h", "6d", "Jc", "Ks"];
    //let my_cards = "AsAh";
    let actions_str = "X-X-R10-C";

    let mut last_raise = 0;
    let mut oop_contribution = 0;
    let mut ip_contribution = 0;

    let actions: Vec<&str> = if actions_str.is_empty() {
        Vec::new()
    } else {
        actions_str.split('-').collect()
    };
    let len = actions.len();

    for (i, action) in actions.into_iter().enumerate() {
        match action.chars().next().unwrap() {
            'X' => {}
            'R' => {
                let value = action[1..].parse::<i32>().unwrap();
                if i % 2 == 0 {
                    // Assume that OOP goes first.
                    oop_contribution += value;
                } else {
                    ip_contribution += value;
                }
                last_raise = value;
            }
            'C' => {
                if i % 2 == 0 {
                    let call_value = last_raise - oop_contribution;
                    oop_contribution += call_value;
                } else {
                    let call_value = last_raise - ip_contribution;
                    ip_contribution += call_value;
                }
            }
            _ => {}
        }
    }

    let final_pot = oop_contribution + ip_contribution + initial_pot;
    let final_effective_stack;

    if len % 2 == 0 {
        final_effective_stack = initial_effective_stack - oop_contribution;
    } else {
        final_effective_stack = initial_effective_stack - ip_contribution;
    }

    println!("Final pot: {}", final_pot);
    println!("Final effective stack: {}", final_effective_stack);

    // Normalize

    let flop_str_temp: String = communite_cards[..3].to_vec().concat();
    let flop_str: &str = flop_str_temp.as_str();
    let flop = flop_from_str(flop_str).unwrap();

    let mut turn = NOT_DEALT;
    if communite_cards.len() >= 4 {
        let turn_str_temp = communite_cards[3..4].to_vec().concat();
        let turn_str = turn_str_temp.as_str();
        turn = card_from_str(turn_str).unwrap();
    }

    let mut river = NOT_DEALT;
    if communite_cards.len() >= 5 {
        let river_str_temp = communite_cards[4..5].to_vec().concat();
        let river_str = river_str_temp.as_str();
        river = card_from_str(river_str).unwrap();
    }

    // Configurating Tree
    let card_config = CardConfig {
        range: [oop_range.parse().unwrap(), ip_range.parse().unwrap()],
        flop: flop,
        turn: NOT_DEALT,
        river: NOT_DEALT,
    };

    let bet_sizes = BetSizeCandidates::try_from(("", "")).unwrap();

    let tree_config = TreeConfig {
        initial_state: BoardState::Flop,
        starting_pot: initial_pot,
        effective_stack: initial_effective_stack,
        rake_rate: 0.0,
        rake_cap: 0.0,
        flop_bet_sizes: [bet_sizes.clone(), bet_sizes.clone()], // [OOP, IP]
        turn_bet_sizes: [bet_sizes.clone(), bet_sizes.clone()],
        river_bet_sizes: [bet_sizes.clone(), bet_sizes.clone()],
        turn_donk_sizes: None, // use default bet sizes
        river_donk_sizes: None,
        add_allin_threshold: 0.0, // add all-in if (maximum bet size) <= 1.5x pot
        force_allin_threshold: 0.0, // force all-in if (SPR after the opponent's call) <= 0.15
        merging_threshold: 0.0,
    };
    let mut action_tree = ActionTree::new(tree_config).unwrap();

    // Building the Tree

    let actions_vec: Vec<&str> = if actions_str.is_empty() {
        Vec::new()
    } else {
        actions_str.split('-').collect()
    };
    let mut actions_line: Vec<Action> = Vec::new();
    for i in 0..actions_vec.len() {
        let previous_action = actions_line.last();
        let action = str_to_action(actions_vec[i], previous_action);
        actions_line.push(action);
        let _ = action_tree.add_line(&actions_line);

        if i == actions_vec.len()-1 {
            let previous_action = actions_line.last();
            if let Some(action) = previous_action {
                match action {
                    Action::Raise(_) | Action::Bet(_)=> {
                        let raise_amounts = [
                            last_raise * 2,
                            last_raise * 3,
                            last_raise * 4,
                            final_effective_stack,
                        ];
                        for amount in raise_amounts.iter() {
                            if *amount > final_effective_stack {
                                let new_action = Action::Bet(final_effective_stack);
                                actions_line.push(new_action);
                                let _ = action_tree.add_line(&actions_line);
                                break;
                            }
                            let new_action = Action::Raise(*amount);
                            actions_line.push(new_action);
                            let _ = action_tree.add_line(&actions_line);
                            actions_line.pop();
                        }
                    }
                    _ => {
                        let pot_percentages = [0.25, 0.3333, 0.5, 0.6666, 0.75, 1.0, 1.25];
                        for percentage in pot_percentages.iter() {
                            let raise_amount = (final_pot as f64 * percentage).floor() as i32;
                            if raise_amount > final_effective_stack {
                                let new_action = Action::Bet(final_effective_stack);
                                actions_line.push(new_action);
                                let _ = action_tree.add_line(&actions_line);
                                break;
                            } else {
                                let new_action = Action::Bet(raise_amount);
                                actions_line.push(new_action);
                                let _ = action_tree.add_line(&actions_line);
                                actions_line.pop();
                            }
                        }
                        let new_action = Action::Bet(final_effective_stack);
                        actions_line.push(new_action);
                        let _ = action_tree.add_line(&actions_line);
                        
                    }
                }
            }
        }
    }
    if actions_vec.is_empty() {
        let pot_percentages = [0.25, 0.3333, 0.5, 0.6666, 0.75, 1.0, 1.25];
        for percentage in pot_percentages.iter() {
            let raise_amount = (final_pot as f64 * percentage).floor() as i32;
            if raise_amount > final_effective_stack {
                let new_action = Action::Bet(final_effective_stack);
                actions_line.push(new_action);
                let _ = action_tree.add_line(&actions_line);
                break;
            } else {
                let new_action = Action::Bet(raise_amount);
                actions_line.push(new_action);
                let _ = action_tree.add_line(&actions_line);
                actions_line.pop();
            }
        }
        let new_action = Action::Bet(final_effective_stack);
        actions_line.push(new_action);
        let _ = action_tree.add_line(&actions_line);
    }


    
    // Initializating the game
    let mut game = PostFlopGame::with_config(card_config, action_tree).unwrap();

    // check memory usage
    let (mem_usage, _) = game.memory_usage();
    println!(
        "Memory usage without compression: {:.2}GB",
        mem_usage as f64 / (1024.0 * 1024.0 * 1024.0)
    );
    
    
    game.allocate_memory(false);

    println!("{:?}", game.added_lines());

    // solve the game
    let start = Instant::now();
    let max_num_iterations = 1000;
    let target_exploitability = game.tree_config().starting_pot as f32 * 0.003; // 0.5% of the pot
    let exploitability = solve(&mut game, max_num_iterations, target_exploitability, true);
    println!("Exploitability: {:.2}", exploitability);
    let duration = start.elapsed();
    println!("Execution Time": {:?}", duration);

    //###################################################START//###################################################

    // Configs
    let mut stage = 0;

    // Loop
    let mut count = 0;
    for action in &actions_vec {

        println!("***********************************************************************");

        let mut find_count = 0;
        for action_print in &actions_vec {
            if action == action_print && find_count==count{
                print!("{} ", action_print.green());
            } else {
                print!("{} ", action_print);
            }
            find_count+=1;
        }
        println!("");
        count += 1;

        if game.is_chance_node() {
            if stage == 0 {
                game.play(turn as usize);
                stage += 1;
                println!("TURN dealt a {}", turn);
            } else if stage == 1 {
                game.play(river as usize);
                stage += 1;
                println!("RIVER dealt a {}", river);
            }
        } 
    
        
        let available_actions = game.available_actions();
        println!("available_actions: {:?}", available_actions);
        let action_choice = match action.chars().next() {
            Some('X') => available_actions
                .iter()
                .position(|&x| matches!(x, Action::Check)),
            Some('F') => available_actions
                .iter()
                .position(|&x| matches!(x, Action::Fold)),
            Some('C') => available_actions
                .iter()
                .position(|&x| matches!(x, Action::Call)),
            Some('R') => {
                let value = action[1..].parse().expect("Invalid number");
                available_actions.iter().position(|&x| match x {
                    Action::Bet(v) => v == value,
                    Action::Raise(v) => v == value,
                    Action::AllIn(v) => v == value,
                    _ => false,
                })
            }
            _ => None,
        };

        if let Some(index) = action_choice {
            game.play(index);
            println!("Perfomed a {:?}", available_actions[index]);
        } else {
            println!("No matching action found");
        }

        if *action == actions_vec[actions_vec.len()-1] && game.is_chance_node(){
            if stage == 0 {
                game.play(turn as usize);
                stage += 1;
                println!("TURN dealt a {}", turn);
            } else if stage == 1 {
                game.play(river as usize);
                stage += 1;
                println!("RIVER dealt a {}", river);
            }
        }
    }
    println!("***********************************************************************");











    
    //GEN
    println!("{}", "GEN".green());

    let player: usize;
    let actions_vec: Vec<&str> = if actions_str.is_empty() {
        Vec::new()
    } else {
        actions_str.split('-').collect()
    };

    if actions_vec.len() == 0 {
        player = 0;
        println!("OOP");
        println!("No actions before!")
    } else if actions_vec.len() % 2 == 0 {
        player = 0;
        println!("OOP");
        for action_print in &actions_vec {
            print!("{} - > ", action_print);
        }
        println!("");
    } else {
        player = 1;
        println!("IP");
        for action_print in &actions_vec {
            print!("{} - > ", action_print);
        }
        println!("");
    }


    

    
    let actions = game.available_actions();
    println!("GEN Possibles Actions: {:?}", actions);
    game.cache_normalized_weights();
    let ev = game.expected_values(player);
    let cards = game.private_cards(player);
    let strategy = game.strategy();
    let expected_values_detail = game.expected_values_detail(player);
    let actions_len = actions.len();
    let cards_len = cards.len();

    println!("actions: {:?}, ev: {:?}, cards: {:?}, strategy: {:?}, expected_values_detail: {:?}", actions.len(), ev.len(), cards.len(), strategy.len(), expected_values_detail.len());

    println!("***********************************************************************");

    for (index, &(card1, card2)) in cards.iter().enumerate() {

        if ev[index]==0.0{
            continue;
        }

        let card1_str = card_to_string(card1)
            .unwrap_or_else(|_| String::from("Error converting card to string"));
        let card2_str = card_to_string(card2)
            .unwrap_or_else(|_| String::from("Error converting card to string"));

        for action_index in 0..actions_len {
            let strategy_index: usize = index + (action_index * cards_len);

            // Usamos `{:?}` em vez de `{}` para imprimir a ação
            let action_name = &actions[action_index];
            let strategy_element = &strategy[strategy_index];
            let expected_values_detail_element = expected_values_detail[strategy_index];
            if card1_str == "2s" && card2_str == "Js"{
                println!(
                    "{}{} | EV: {:<6} | Strategy: {:<9} | chance: {:<5} | ev: {:<6} |",
                    card1_str,
                    card2_str,
                    format!("{:.3}", ev[index]),
                    format!("{:?}", action_name),
                    format!("{:.3}", strategy_element),
                    format!("{:.3}", expected_values_detail_element)
                );
            }
            
        }
    }

    println!("***********************************************************************");
    
}

OUTPUT:
Final pot: 22
Final effective stack: 15
Memory usage without compression: 0.25GB
[[Check, Check, Bet(10)], [Check, Check, Bet(10), Call, Bet(5)], [Check, Check, Bet(10), Call, Bet(7)], [Check, Check, Bet(10), Call, Bet(11)], [Check, Check, Bet(10), Call, Bet(14)], [Check, Check, Bet(10), Call, AllIn(15)]]
iteration: 40 / 1000 (exploitability = 3.7834e-3)
Exploitability: 0.00
Execution Time: 40.0114349s

---

X X R10 C
available_actions: [Check]
Perfomed a Check

---

X X R10 C
available_actions: [Check]
Perfomed a Check

---

X X R10 C
TURN dealt a 36
available_actions: [Check, Bet(10)]
Perfomed a Bet(10)

---

X X R10 C
available_actions: [Fold, Call]
Perfomed a Call
RIVER dealt a 47

---

GEN
OOP
X - > X - > R10 - > C - >
GEN Possibles Actions: [Check, Bet(5), Bet(7), Bet(11), Bet(14), AllIn(15)]
actions: 6, ev: 966, cards: 966, strategy: 5796, expected_values_detail: 5796

---

2sJs | EV: 19.824 | Strategy: Check | chance: 0.000 | ev: 17.482 |
2sJs | EV: 19.824 | Strategy: Bet(5) | chance: 0.004 | ev: 19.427 |
2sJs | EV: 19.824 | Strategy: Bet(7) | chance: 0.046 | ev: 19.783 |
2sJs | EV: 19.824 | Strategy: Bet(11) | chance: 0.889 | ev: 19.846 |
2sJs | EV: 19.824 | Strategy: Bet(14) | chance: 0.019 | ev: 19.678 |
2sJs | EV: 19.824 | Strategy: AllIn(15) | chance: 0.042 | ev: 19.509 |

---

It takes 40s to run the code, but in Desktop Postflop with the same configurations it take only 1.27s. Why this difference?

[b-inary]

How did you set the compile options? If you do not specify the --release flag in the execution command, the program runs in debug mode, which is much slower than the release mode.
If you are already running in release mode, I can't think of a reason why. It seems to me that you are properly comparing with the same condition.

[dolglao]

It worked! I don't understand much about Rust. Thank you !