我根据原来的分布式的设计，实现了分布式仿真的方法，但是对各种数据的存储一直不太熟练，所有的设计都记录在

分布式仿真思考（三）成功运行啦，哈哈哈-CSDN博客

在这里，我将每个进程都存储这全局的邻接表，本地邻接表，如下

	// 神经元的邻接表
	std::vector<std::vector<int>> global_adjacency;
	// 全局每个神经元的出度
	std::vector<int> global_out_degree;
	// 本地的邻接表
	std::vector<std::vector<int>> local_adjcency;
	//本地的突触集合
	std::vector<int> local_node_gids;

在实例化神经元和突触时:

     //实例化本地神经元，加入到local_nodes集合
    for (int i = 0; i < local_node_gids.size(); i++)
    {
        Neuron* node = new Neuron(realDist(gen), local_node_gids[i]);
        local_nodes.push_back(node);
    }
     //实例化本地突触，并加入local_synapases
    for (int ii = 0; ii < local_adjcency.size(); ii++)
    {
        if (local_adjcency.size()==0)
        {
            continue;
        }
        for (int jj = 0; jj < local_adjcency[ii].size(); jj++)
        {
            // 获取突触后神经元的位置
            auto it = std::find(local_node_gids.begin(), local_node_gids.end(), local_adjcency[ii][jj]);
            // 转成本地神经元的下标
            int idx = std::distance(local_node_gids.begin(),it);
            
            Synapse* synapase = new Synapse(min_delay, 0.2, local_nodes[idx]);
            local_synapases[ii].push_back(synapase);
        }
    }

看一看出来在创建的过程中消耗了大部分的内存，所我决定重新设计一下，以减少内存的使用，其实问题最大的难点依旧在，脉冲的传输阶段，需要准确判断脉冲需要发送的位置，我之前的做法是这样

/// <summary>
/// 判断本地脉冲和远程脉冲
/// 该神经元存在本地脉冲，存在则返回ture
/// 该神经元存在远程脉冲，返回远程脉冲所在的进程id集合
/// </summary>
/// <param name="is_post_syn">是否存在本地脉冲</param>
/// <param name="remote_proc_id">远程脉冲所在的进程id集合</param>
void judge_remote_pluses(const int sender_gid, bool& is_local,std::vector<int>& remote_proc_id);
void ConnectionManager::judge_remote_pluses(const int sender_gid,bool& is_local, std::vector<int>& remote_proc_id)
{
 
    // 获取分区情况
     std::vector<int> partition(0);
    // 本进程的id
    int rank_ = kernel().mpi_manager.get_rank();

    if (local_adjcency[sender_gid].size() == global_adjacency[sender_gid].size())
    {
        is_local = true;
    }
    else if(local_adjcency[sender_gid].size() < global_adjacency[sender_gid].size())
    {
        for (int ii = 0; ii < global_adjacency[sender_gid].size(); ii++)
        {

            if (partition[global_adjacency[sender_gid][ii]] == rank_)
            {
                is_local = true;
            }
            else
            {
                remote_proc_id.push_back(partition[global_adjacency[sender_gid][ii]]);
            }
        }
    }
}

那时候我就在想，这些事情是不是可以提前做，避免脉冲的脉冲的判断，比如定义一个std::unordered_map<int, std::vector<int>> communication_diagram这样一个通信图， key值是神经元的gid，value代表需要通信的进程id集合。

还有一点需要考虑，比如考虑如下种群创建实例

而不同population之间的创建需要设置突触的初始参数

	// 神经元群落集合 种群中包括该神经元的所有初始参数
	std::vector<Population *> populations;
	// 突触参数集合 col代表前种群id row代表后种群id syn_params[i][j]表示连接这两个种群的参数
	std::vector<std::vector< SynapseParams *>> syn_params;
	// 神经元的邻接表
	std::vector<std::vector<int>> global_adjacency;
	// 全局每个神经元的出度
	std::vector<int> global_out_degree;

那么创建种群的代码如下

int ConnectionManager::create(int num, const NeuronParams& nparams)
{ 

    Population* pops = new Population(nparams);
    pops->set_num_neurons(num);

    设置神经元的gid
    int min_gid = tail_pointer;
    int max_gid = tail_pointer + num;
    for (int ii = min_gid, jj = 0; ii < max_gid; ii++, jj++)
    {
        pops->add_neuron_gid(jj, ii);
    }
    tail_pointer = max_gid;
 
    // 调整全局邻接矩阵的大小
    global_adjacency.resize(tail_pointer);
    // 设置每个突触的出度
    global_out_degree.resize(tail_pointer);
    //将种群加入种群集合
    populations.push_back(pops);
    //设置突触参数大小
    syn_params.resize(populations.size(), std::vector<SynapseParams*>(populations.size()));

    return pops->get_group_id();
}

明天计划写connect的代码