bool initialize_packet_slinger()
{
if (slinger_initialized) return true;
initialize_slinger_frame_lookup();
e_memset(link_state, 0, 2 * sizeof(slinger_link_state_t));
link_state[slinger_link_highrate].link_enum = slinger_link_highrate;
link_state[slinger_link_biphase].link_enum = slinger_link_biphase;
link_state[slinger_link_highrate].downlink_pq = create_pq(SLINGER_MAX_PRIORITY);
link_state[slinger_link_biphase].downlink_pq = create_pq(SLINGER_MAX_PRIORITY);
link_state[slinger_link_highrate].resend_fifo = fifo_new();
link_state[slinger_link_biphase].resend_fifo = fifo_new();
link_state[slinger_link_highrate].control_fifo_queue = fifo_new();
link_state[slinger_link_highrate].downlink_fifo = fifo_new();
link_state[slinger_link_biphase].control_fifo_queue = fifo_new();
link_state[slinger_link_biphase].downlink_fifo = fifo_new();
link_state[slinger_link_highrate].fifo_pause_us = 50000;
link_state[slinger_link_biphase].fifo_pause_us = 9984;
link_state[slinger_link_highrate].device = bstrdup(err, "/dev/ttyHighRate");
link_state[slinger_link_biphase].device = bstrdup(err, "/dev/bi0_pci");
link_state[slinger_link_biphase].bps = 1000000;
/// Initialize the downlink rate for TDRSS Omni-directional
set_slinger_dl_rate(CommandData.packet_slinger.downlink_rate_bps);
initialize_slinger_tables();
if (!slinger_xml_load_preferences("/data/etc/packetslinger.xml")) return false;
slinger_initialized = true;
return true;
}
/**
* Compute the union of 'number' bitmaps using a heap. This can
* sometimes be faster than roaring_bitmap_or_many which uses
* a naive algorithm. Caller is responsible for freeing the
* result.
*/
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
const roaring_bitmap_t **x) {
if (number == 0) {
return roaring_bitmap_create();
}
if (number == 1) {
return roaring_bitmap_copy(x[0]);
}
roaring_pq_t *pq = create_pq(x, number);
while (pq->size > 1) {
roaring_pq_element_t x1 = pq_poll(pq);
roaring_pq_element_t x2 = pq_poll(pq);
if (x1.is_temporary && x2.is_temporary) {
roaring_bitmap_t *newb =lazy_or_from_lazy_inputs(x1.bitmap,
x2.bitmap);
uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
roaring_pq_element_t newelement = { .size = bsize, .is_temporary =
true, .bitmap = newb };
pq_add(pq, &newelement);
} else if (x2.is_temporary) {
roaring_bitmap_lazy_or_inplace(x2.bitmap, x1.bitmap);
x2.size = roaring_bitmap_portable_size_in_bytes(x2.bitmap);
pq_add(pq, &x2);
} else if (x1.is_temporary) {
roaring_bitmap_lazy_or_inplace(x1.bitmap, x2.bitmap);
x1.size = roaring_bitmap_portable_size_in_bytes(x1.bitmap);
pq_add(pq, &x1);
} else {
roaring_bitmap_t *newb = roaring_bitmap_lazy_or(x1.bitmap,
x2.bitmap);
uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
roaring_pq_element_t newelement = { .size = bsize, .is_temporary =
true, .bitmap = newb };
pq_add(pq, &newelement);
}
}
roaring_pq_element_t X = pq_poll(pq);
roaring_bitmap_t *answer = X.bitmap;
roaring_bitmap_repair_after_lazy(answer);
pq_free(pq);
return answer;
}
/**
* Compute the union of 'number' bitmaps using a heap. This can
* sometimes be faster than roaring_bitmap_or_many which uses
* a naive algorithm. Caller is responsible for freeing the
* result.
*/
roaring_bitmap_t *roaring_bitmap_or_many_heap(uint32_t number,
const roaring_bitmap_t **x) {
if (number == 0) {
return roaring_bitmap_create();
}
if (number == 1) {
return roaring_bitmap_copy(x[0]);
}
roaring_pq_t *pq = create_pq(x, number);
while (pq->size > 1) {
roaring_pq_element_t x1 = pq_poll(pq);
roaring_pq_element_t x2 = pq_poll(pq);
if (x1.is_temporary && x2.is_temporary) {
roaring_bitmap_t *newb =
lazy_or_from_lazy_inputs(x1.bitmap, x2.bitmap);
// should normally return a fresh new bitmap *except* that
// it can return x1.bitmap or x2.bitmap in degenerate cases
bool temporary = !((newb == x1.bitmap) && (newb == x2.bitmap));
uint64_t bsize = roaring_bitmap_portable_size_in_bytes(newb);
roaring_pq_element_t newelement = {
.size = bsize, .is_temporary = temporary, .bitmap = newb};
pq_add(pq, &newelement);
} else if (x2.is_temporary) {
