Method sample

include/core/solver.h:1012–1055

Sample edges. This function can be parallelized. */

    /** Sample edges. This function can be parallelized. */
    void sample(int start, int end) {
        CUDA_CHECK(cudaSetDevice(device_id));

        random.to_host();
        CURAND_CHECK(curandGenerateUniformDouble(generator, random.device_ptr, kRandBatchSize));

        auto &sample_pool = solver->sample_pools[solver->pool_id ^ 1];
        std::vector<std::vector<int>> offsets(num_partition);
        for (auto &&partition_offsets : offsets)
            partition_offsets.resize(num_partition, start);
        int num_complete = 0, rand_id = 0;
        std::vector<std::pair<int, Index>> heads(solver->sample_batch_size);
        std::vector<std::pair<int, Index>> tails(solver->sample_batch_size);
        std::vector<Attributes> attributes(solver->sample_batch_size);
        while (num_complete < num_partition * num_partition) {
            for (int i = 0; i < solver->sample_batch_size; i++) {
                if (rand_id > kRandBatchSize - 2) {
                    random.to_host();
                    CURAND_CHECK(curandGenerateUniformDouble(generator, random.device_ptr, kRandBatchSize));
                    rand_id = 0;
                }
                size_t edge_id = solver->edge_table.sample(random[rand_id++], random[rand_id++]);

                Index head_global_id = std::get<0>(solver->graph->edges[edge_id]);
                Index tail_global_id = std::get<1>(solver->graph->edges[edge_id]);
                heads[i] = solver->head_locations[head_global_id];
                tails[i] = solver->tail_locations[tail_global_id];
                attributes[i] = get_attributes(solver->graph->edges[edge_id]);
            }
            for (int i = 0; i < solver->sample_batch_size; i++) {
                int head_partition_id = heads[i].first;
                int tail_partition_id = tails[i].first;
                int &offset = offsets[head_partition_id][tail_partition_id];
                if (offset < end) {
                    auto &pool = sample_pool[head_partition_id][tail_partition_id];
                    Index head_local_id = heads[i].second;
                    Index tail_local_id = tails[i].second;
                    pool[offset] = std::tuple_cat(std::tie(head_local_id, tail_local_id), attributes[i]);
                    if (++offset == end)
                        num_complete++;
                }
            }
        }
    }

    /** Count edges for each sample block. This function can be parallelized. */
    void count(size_t start, size_t end, int id) {