concurrent.futures.ProcessPoolExecutor(): json file is not created

Question

I'm new to this package. When studying the codes from https://github.com/diningphil/graph-mixture-density-networks (with some minor modification). In the notebook file SIR Simulation with DGL_ERDOS-RENYI.ipynb, during the simulation process, I encountered a weird thing: If I set debug = True, which means I'm not using the pool = concurrent.futures.ProcessPoolExecutor(max_workers=processes) but just run it one by one, both the .json files and the .bin files will be created according to the json_filepath variable.

However, when I deleted the output and run it by setting debug = False so all the codes will run simultaneously if my understanding is correct, but the json_file will not be created and the program seems to terminate at the step graph.to(torch.device(device)) as all my print command is not executed afterward. I only have the .bin files created.

Could anyone help me by telling me the possible reason or waht I should do about it? Thanks a lot!

'''

run simulation and store 
    1) state of all nodes at each time step
    into a single pandas dataframe for all beta, gamma and repetitions
    2) R_0
    3) number of total people infected (total - susceptible at the end of the iteration) 
'''
     
seed = 38
torch.manual_seed(seed)
device = 'cuda'

beta_range = [0, 1]
gamma_range = [0.1, 1]
iterations = 5

no_graph_samples = 20
no_realizations = 100

family_name = 'erdos_renyi'        
folder = Path(f'{family_name}')

if not os.path.exists(folder):
    os.makedirs(folder)

def simulate(p, graph_size, graph_sample, graphs_folder):

    json_filepath = str(Path(graphs_folder, f'data_{graph_sample}.json'))
    graph_filename = graphs_folder / Path(f'sample{graph_sample}.bin')

    json_data = {'family': family_name,
                 'p': p,
                 'graph_size': graph_size,
                 'no_graph_samples': no_graph_samples,
                 'graph_samples': []
                }

    sample = {'graph_filename': str(graph_filename),
              'simulations': []}
    
    if not os.path.exists(graph_filename):
        graph = create_erdos_renyi_graph(graph_size, p)
        save_graphs(str(graph_filename), graph)
    else:
        graph = load_graphs(str(graph_filename))[0][0]
    #print('test')
    graph.to(torch.device(device))

    ## every code above this line will run, at least print() will work
    if not os.path.exists(json_filepath):
        print('test: json_does not exit')
        for realizations in range(no_realizations):
            
            beta = float(torch.FloatTensor(1).uniform_(beta_range[0], beta_range[1]))
            gamma = float(torch.FloatTensor(1).uniform_(gamma_range[0], gamma_range[1]))
            R0 = beta/gamma
            graph.register_message_func(lambda x: SIR_message_func(beta, x))
            graph.register_reduce_func(lambda x: SIR_reduce_func(gamma, x))

            for initial_probability_of_infection in [0.01, 0.05, 0.1]:

                simulation = {'beta': beta, 'gamma': gamma, 'R0': R0, 'init_infection_prob': initial_probability_of_infection}

                S, I, R, first_infected = simulate_SIR(graph, initial_probability_of_infection, iterations)
                simulation['S'] = S
                simulation['I'] = I
                simulation['R'] = R
                simulation['first_infected'] = first_infected
                simulation['total_infected'] = graph_size - S[-1]
                sample['simulations'].append(deepcopy(simulation))
                                
                #print("Realization ", realizations, "produced ", graph_size - S[-1], "infected")
        
        json_data['graph_samples'].append(sample)
        
        with open(json_filepath, 'w') as f:
            line = json.dumps(json_data)
            f.write(line + '\n')
            #json.dump(json_data, f)
            print('dumped')
    else:
        print('test: there is json')
    print(sample)
#         with open(json_filepath, 'r') as f:
#             json.load(f)
#             print('loaded but why')
            


debug = False
processes = 100
import concurrent.futures
pool = concurrent.futures.ProcessPoolExecutor(max_workers=processes)

#for graph_size in [10, 50, 100, 200, 500, 1000]:
for graph_size in [10]:
    for p in [0.01, 0.05]:
    #for p in [0.01, 0.05, 0.1, 0.2, 0.3, 0.5]:
        
        graphs_folder = folder / Path(f'graphs_size{graph_size}_p{float(p)}')

        #store each graph in a different folder (create path based on graph size, prob of edge and graph sample)
        if not os.path.exists(graphs_folder):
            os.makedirs(graphs_folder)

        for graph_sample in range(no_graph_samples):  

            if not debug:
                pool.submit(simulate, p, graph_size, graph_sample, graphs_folder)
            else:  # DEBUG
                simulate(p, graph_size, graph_sample, graphs_folder)

pool.shutdown()  # wait the batch of configs to terminate