struct peer_profile_t* add_peer()
{
struct peer_profile_t * p = (struct peer_profile_t *)malloc(sizeof(struct peer_profile_t));
if(p == NULL)
{
ERROR(errno, "add_peer: malloc failed");
return NULL;
}
else
bzero(p, sizeof(struct peer_profile_t));
struct sockaddr_in * peeraddr = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
if(peeraddr == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
{
bzero(peeraddr, sizeof(struct sockaddr_in));
p->peeraddr = peeraddr;
}
uint32_t * pkt_index_array_pre = (uint32_t *)malloc(SEQ_LEVEL_1*sizeof(uint32_t));
if(peeraddr == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
{
bzero(pkt_index_array_pre, SEQ_LEVEL_1*sizeof(uint32_t));
p->pkt_index_array_pre = pkt_index_array_pre;
}
uint32_t * pkt_index_array_now = (uint32_t *)malloc(SEQ_LEVEL_1*sizeof(uint32_t));
if(peeraddr == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
{
bzero(pkt_index_array_now, SEQ_LEVEL_1*sizeof(uint32_t));
p->pkt_index_array_now = pkt_index_array_now;
}
p->tcp_info = (struct tcp_info_t *)malloc(TCP_SESSION_CNT * sizeof(struct tcp_info_t));
if(p->tcp_info == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bzero(p->tcp_info, TCP_SESSION_CNT * sizeof(struct tcp_info_t));
p->tcp_cnt = 0;
p->timerfd_info = (struct timerfd_info_t *)malloc(sizeof(struct timerfd_info_t));
if(p->timerfd_info == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bzero(p->timerfd_info, sizeof(struct timerfd_info_t));
p->timerfd_info->fd_max_cnt = TIMER_CNT;
p->timerfd_info->ack_array_size = SEQ_LEVEL_1;
p->timerfd_info->ack_array_pre = (struct ack_info_t *)malloc((p->timerfd_info->ack_array_size + 1) * sizeof(struct ack_info_t));
if(p->timerfd_info->ack_array_pre == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bzero(p->timerfd_info->ack_array_pre, (p->timerfd_info->ack_array_size + 1) * sizeof(struct ack_info_t));
p->timerfd_info->ack_array_now = (struct ack_info_t *)malloc((p->timerfd_info->ack_array_size + 1) * sizeof(struct ack_info_t));
if(p->timerfd_info->ack_array_now == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bzero(p->timerfd_info->ack_array_now, (p->timerfd_info->ack_array_size +1 ) * sizeof(struct ack_info_t));
p->flow_src = (struct flow_profile_t *)malloc(sizeof(struct flow_profile_t));
if(p->flow_src == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bzero(p->flow_src, sizeof(struct flow_profile_t));
p->flow_src->ba_pre = bit_array_create(SEQ_LEVEL_1);
if(p->flow_src->ba_pre == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bit_array_clearall(p->flow_src->ba_pre);
p->flow_src->ba_now = bit_array_create(SEQ_LEVEL_1);
if(p->flow_src->ba_now == NULL)
{
ERROR(errno, "add_peer: malloc failed");
delete_peer(p);
return NULL;
}
else
bit_array_clearall(p->flow_src->ba_now);
p->valid = true;
return p;
}
bool RapMapSAIndex<IndexT>::load(const std::string& indDir) {
auto logger = spdlog::get("stderrLog");
size_t n{0};
// This part takes the longest, so do it in it's own asynchronous task
std::future<std::pair<bool, uint32_t>> loadingHash = std::async(std::launch::async, [this, logger, indDir]() -> std::pair<bool, uint32_t> {
this->khash.set_empty_key(std::numeric_limits<uint64_t>::max());
uint32_t k;
std::ifstream hashStream(indDir + "hash.bin");
{
logger->info("Loading Position Hash");
cereal::BinaryInputArchive hashArchive(hashStream);
hashArchive(k);
khash.unserialize(typename google::dense_hash_map<uint64_t,
rapmap::utils::SAInterval<IndexT>,
rapmap::utils::KmerKeyHasher>::NopointerSerializer(), &hashStream);
//hashArchive(khash);
}
hashStream.close();
return std::make_pair(true, k);
});
std::ifstream saStream(indDir + "sa.bin");
{
logger->info("Loading Suffix Array ");
cereal::BinaryInputArchive saArchive(saStream);
saArchive(SA);
//saArchive(LCP);
}
saStream.close();
std::ifstream seqStream(indDir + "txpInfo.bin");
{
logger->info("Loading Transcript Info ");
cereal::BinaryInputArchive seqArchive(seqStream);
seqArchive(txpNames);
seqArchive(txpOffsets);
//seqArchive(positionIDs);
seqArchive(seq);
}
seqStream.close();
/*
std::ifstream rsStream(indDir + "rsdSafe.bin", std::ios::binary);
{
logger->info("Loading Rank-Select Data");
rankDictSafe.Load(rsStream);
}
rsStream.close();
*/
std::string rsFileName = indDir + "rsd.bin";
FILE* rsFile = fopen(rsFileName.c_str(), "r");
{
logger->info("Loading Rank-Select Bit Array");
bitArray.reset(bit_array_create(0));
if (!bit_array_load(bitArray.get(), rsFile)) {
logger->error("Couldn't load bit array from {}!", rsFileName);
std::exit(1);
}
logger->info("There were {} set bits in the bit array", bit_array_num_bits_set(bitArray.get()));
rankDict.reset(new rank9b(bitArray->words, bitArray->num_of_bits));
}
fclose(rsFile);
{
logger->info("Computing transcript lengths");
txpLens.resize(txpOffsets.size());
if (txpOffsets.size() > 1) {
for(size_t i = 0; i < txpOffsets.size() - 1; ++i) {
auto nextOffset = txpOffsets[i+1];
auto currentOffset = txpOffsets[i];
txpLens[i] = (nextOffset - 1) - currentOffset;
}
}
// The last length is just the length of the suffix array - the last offset
txpLens[txpOffsets.size()-1] = (SA.size() - 1) - txpOffsets[txpOffsets.size() - 1];
}
logger->info("Waiting to finish loading hash");
loadingHash.wait();
auto hashLoadRes = loadingHash.get();
if (!hashLoadRes.first) {
logger->error("Failed to load hash!");
std::exit(1);
}
rapmap::utils::my_mer::k(hashLoadRes.second);
logger->info("Done loading index");
return true;
}
