int cache_header_dump(uint8_t *b, const struct peer_cache *c, int include_me)
{
int_cpy(b, c->cache_size + (include_me ? 1 : 0));
int_cpy(b + 4, c->metadata_size);
return 8;
}
int entry_dump(uint8_t *b, const struct peer_cache *c, int i, size_t max_write_size)
{
int res;
int size = 0;
if (i && (i >= c->cache_size - 1)) {
return 0;
}
int_cpy(b, c->entries[i].timestamp);
size = +4;
res = nodeid_dump(b + size, c->entries[i].id, max_write_size - size);
if (res < 0 ) {
return -1;
}
size += res;
if (c->metadata_size) {
if (c->metadata_size > max_write_size - size) {
return -1;
}
memcpy(b + size, c->metadata + c->metadata_size * i, c->metadata_size);
size += c->metadata_size;
}
return size;
}
void CHM_rs::copy_contents(CHM_r *SRC) {
CHM_SP src = (dynamic_cast<CHM_rs*>(SRC))->A;
int m = (int)A->nrow, n = (int)A->ncol;
if (!(m == (int)src->nrow && n == (int)src->ncol))
error(_("%s mismatch: src is %d by %d, dest is %d by %d"),
"CHM_rs::copy_contents",
(int)src->nrow, (int)src->ncol, m, n);
size_t nnz = ((int*)src->p)[n];
if (A->nzmax < nnz)
error(_("%s mismatch: src has %d non-zeros, dest->nzmax = %d"),
"CHM_rs::copy_contents", nnz, ((int*)A->p)[n]);
if (A->itype != src->itype || A->xtype != src->xtype ||
A->dtype != src->dtype)
error(_("%s mismatch: on itype, xtype or dtype"),
"CHM_rs::copy_contents");
int_cpy((int*)A->p, (int*)src->p, n + 1);
int_cpy((int*)A->i, (int*)src->i, nnz);
dble_cpy((double*)A->x, (double*)src->x, nnz);
A->stype = src->stype; A->sorted = src->sorted;
if (!src->packed) error(_("%s: only packed src can be copied"),
"CHM_rs::copy_contents");
A->packed = 1;
}
int encodeChunk(const struct chunk *c, uint8_t *buff, int buff_len)
{
uint32_t half_ts;
if (buff_len < 20 + c->size + c->attributes_size) {
/* Not enough space... */
return -1;
}
int_cpy(buff, c->id);
half_ts = c->timestamp >> 32;
int_cpy(buff + 4, half_ts);
half_ts = c->timestamp;
int_cpy(buff + 8, half_ts);
int_cpy(buff + 12, c->size);
int_cpy(buff + 16, c->attributes_size);
memcpy(buff + 20, c->data, c->size);
if (c->attributes_size) {
memcpy(buff + 20 + c->size, c->attributes, c->attributes_size);
}
return 20 + c->size + c->attributes_size;
}
int encodeChunkSignaling(const struct chunkID_set *h, const void *meta, int meta_len, uint8_t *buff, int buff_len)
{
int i;
uint8_t *meta_p;
uint32_t type = h ? h->type : -1;
int_cpy(buff + 4, type);
int_cpy(buff + 8, meta_len);
switch (type) {
case CIST_BITMAP:
{
int elements;
uint32_t c_min, c_max;
c_min = c_max = h->n_elements ? h->elements[0] : 0;
for (i = 1; i < h->n_elements; i++) {
if (h->elements[i] < c_min)
c_min = h->elements[i];
else if (h->elements[i] > c_max)
c_max = h->elements[i];
}
elements = h->n_elements ? c_max - c_min + 1 : 0;
int_cpy(buff, elements);
elements = elements / 8 + (elements % 8 ? 1 : 0);
if (buff_len < elements + 16 + meta_len) {
return -1;
}
int_cpy(buff + 12, c_min); //first value in the bitmap, i.e., base value
memset(buff + 16, 0, elements);
for (i = 0; i < h->n_elements; i++) {
buff[16 + (h->elements[i] - c_min) / 8] |= 1 << ((h->elements[i] - c_min) % 8);
}
meta_p = buff + 16 + elements;
break;
}
case CIST_PRIORITY:
int_cpy(buff, h->n_elements);
if (buff_len < h->n_elements * 4 + 12 + meta_len) {
return -1;
}
for (i = 0; i < h->n_elements; i++) {
int_cpy(buff + 12 + i * 4, h->elements[i]);
}
meta_p = buff + 12 + h->n_elements * 4;
break;
case -1:
int_cpy(buff, 0);
meta_p = buff + 12;
break;
default:
fprintf(stderr, "Invalid ChunkID encoding type %d\n", type);
return -1;
}
if (meta_len) {
memcpy(meta_p, meta, meta_len);
}
return meta_p + meta_len - buff;
}
