BranchingDynamics runs about 10 times slower than ConfiguringDynamics

[cloud-waiting-for-wind]

Ecole provides a very convenient and powerful tool to allow developers to operate each branch of SCIP. However, I try to compare the speed of BranchingDynamics and ConfiguringDynamics (or default SCIP with "fullstrong" method) on an instance of NIPS2021 ML4CO competition (actually, it is 'instances/1_item_placement/train/item_placement_0.mps.gz'). The time limit is set to 20 seconds, and then I observe the number of nodes that have been computed by BranchingDynamics or ConfiguringDynamics.

It can be found that ConfiguringDynamics computes 238 nodes in 20s, whereas BranchingDynamics can only compute 14 nodes. Moreover, it is obvious that within 20 seconds, this instance cannot achieve the optimal solution. In other words, the problem is still being solved, but ConfiguringDynamics is progressing faster

Here is the code, and it seems that the hyperparameters of both are the same. I wonder why there was such a big speed difference between the two methods. Is it because BranchingDynamics has to sacrifice a lot of speed in order to get intermediate results compared to ConfiguringDynamics? I would be very grateful if you could answer my questions or point out the problem/bug in my code

import ecole
from pyscipopt import scip
import matplotlib.pyplot as plt

class SimpleConfiguringDynamics(ecole.dynamics.ConfiguringDynamics):
    def __init__(self, branching_method=None, time_limit = 60):
        super().__init__()
        self.branching_method = branching_method
        self.time_limit = time_limit

    def reset_dynamics(self, model):
        pyscipopt_model = model.as_pyscipopt()
        if self.branching_method is not None: 
            pyscipopt_model.setParam("branching/" + self.branching_method + "/priority", 10001)
        
        reset_time = pyscipopt_model.getSolvingTime()
        pyscipopt_model.setParam("limits/time", self.time_limit + reset_time)
        return super().reset_dynamics(model)
    
class SimpleBranchingDynamics(ecole.dynamics.BranchingDynamics):
    def __init__(self, time_limit = 60):
        super().__init__()
        self.time_limit = time_limit

    def reset_dynamics(self, model):
        pyscipopt_model = model.as_pyscipopt()        
        reset_time = pyscipopt_model.getSolvingTime()
        pyscipopt_model.setParam("limits/time", self.time_limit + reset_time)
        return super().reset_dynamics(model)




class SimpleBranching(ecole.environment.Environment):
    __Dynamics__ = SimpleBranchingDynamics

class SimpleConfiguring(ecole.environment.Environment):
    __Dynamics__ = SimpleConfiguringDynamics





#%%
instance = '../../instances/1_item_placement/train/item_placement_0.mps.gz'
full_sb_env = SimpleConfiguring(observation_function=None,
                                   branching_method="fullstrong",
                                   time_limit = 20,
                                   information_function=ecole.reward.NNodes())
full_sb_env.seed(0)


observation, action_set, _, done, info = full_sb_env.reset(instance)
_, _, _, _, info = full_sb_env.step({})
print('nodes in 20s  by ConfiguringDynamics: ', info)




handwritten_sb_env = SimpleBranching(observation_function=ecole.observation.StrongBranchingScores(),
                                     time_limit = 20,
                                     information_function=ecole.reward.NNodes())
handwritten_sb_env.seed(0)
observation, action_set, _, done, info = handwritten_sb_env.reset(instance)
nb_nodes = info
while not done:
    sb_scores = observation
    action = action_set[sb_scores[action_set].argmax()]
    observation, action_set, _, done, info = handwritten_sb_env.step(action)
    nb_nodes += info
print('nodes in 20s  by BranchingDynamics: ', nb_nodes)

output of above code:
nodes in 20s by ConfiguringDynamics: 238.0
nodes in 20s by BranchingDynamics: 14.0

My ecole version is 0.7.3 and the pyscipopt version is 3.4.0