int bitset_resize(bitset* bset, int new_size) {
int prev_buffer_size = calculate_buffer_size(bset->total_bits);
int buffer_size = calculate_buffer_size(new_size);
if(prev_buffer_size < buffer_size) {
unsigned short int* temp = realloc(bset->bit_buffer, buffer_size);
if(temp == NULL) {
return BITSET_ALLOC_ERROR;
}
int prev_total_buckets = (prev_buffer_size / SHORT_INT_SIZE);
int new_buckets = (buffer_size / SHORT_INT_SIZE) - prev_total_buckets;
memset(temp + prev_total_buckets, 0, new_buckets * SHORT_INT_SIZE);
bset->bit_buffer = temp;
}
bset->total_bits = new_size;
return BITSET_SUCCESS;
}
void bitset_serialize(bitset* bset, FILE* fp) {
fwrite(&bset->total_bits, 1, sizeof(unsigned int), fp);
int buffer_size = calculate_buffer_size(bset->total_bits);
fwrite(bset->bit_buffer, buffer_size, 1, fp);
}
char *
bits_save (BITS *bits)
{
int
block_nbr; /* Bitstring block number */
word
comp_size; /* Size of compressed block */
BITBLOCK
*block_ptr; /* Points to bitstring block */
byte
*buffer = NULL, /* Stream buffer */
*position; /* Current position in the stream */
long
size;
char
*encoded = NULL;
ASSERT (bits);
size = calculate_buffer_size (bits);
buffer = mem_alloc (size);
if (buffer)
{
position = buffer;
/* Write bitstring header to stream */
*((int *)position) = bits-> block_count;
position += sizeof (bits-> block_count);
*((dbyte *)position) = bits-> free_list;
position += sizeof (bits-> free_list);
/* Write bitstring blocks to stream */
for (block_nbr = 0; block_nbr < bits-> block_count; block_nbr++)
{
block_ptr = bits-> block [block_nbr];
comp_size = compress_block (block_ptr-> block.data,
compressed, (word)BIT_DATASIZE);
*((dbyte *)position) = block_ptr-> right;
position += sizeof (block_ptr-> right);
*((int *)position) = block_ptr-> size;
position += sizeof (block_ptr-> size);
*((word *)position) = comp_size;
position += sizeof (word);
memcpy (position, compressed, comp_size);
position += comp_size;
}
/* Encode binary buffer in base64 */
encoded = mem_alloc ((long)((double) size * 1.5) + 2);
if (encoded)
encode_base64 (buffer, encoded, size);
mem_free (buffer);
}
return (encoded);
}
/* TODO: this is very similar to snis_server's version of same function */
static int __attribute__((unused)) read_and_unpack_buffer(struct starsystem_info *ss, unsigned char *buffer, char *format, ...)
{
va_list ap;
struct packed_buffer pb;
int rc, size = calculate_buffer_size(format);
rc = snis_readsocket(ss->socket, buffer, size);
if (rc != 0)
return rc;
packed_buffer_init(&pb, buffer, size);
va_start(ap, format);
rc = packed_buffer_extract_va(&pb, format, ap);
va_end(ap);
return rc;
}
int bitset_deserialize(bitset** bset, FILE* fp) {
int bitset_size;
fread(&bitset_size, 1, sizeof(unsigned int), fp);
bitset* out;
int creation_status = bitset_create(&out, bitset_size);
if(creation_status != BITSET_SUCCESS) {
return creation_status;
}
int buffer_size = calculate_buffer_size(bitset_size);
fread(out->bit_buffer, buffer_size, 1, fp);
(*bset) = out;
return BITSET_SUCCESS;
}
int bitset_create(bitset** bset, unsigned int size) {
bitset* retval = malloc(sizeof(bitset));
if(retval == NULL) {
(*bset) = NULL;
return BITSET_ALLOC_ERROR;
}
retval->total_bits = 0;
int buffer_size = calculate_buffer_size(size);
retval->bit_buffer = malloc(buffer_size);
if(retval->bit_buffer == NULL) {
free(retval);
(*bset) = NULL;
return BITSET_ALLOC_ERROR;
}
memset(retval->bit_buffer, 0, buffer_size);
retval->total_bits = size;
(*bset) = retval;
return BITSET_SUCCESS;
}
int main(int argc, char** argv)
{
struct options options;
if (process_options(argc, argv, true, &options) != 0)
return 0;
if (options.rmat.a + options.rmat.b + options.rmat.c >= 1) {
printf("Error: The sum of probabilities must equal 1\n");
return 0;
}
double d = 1 - (options.rmat.a + options.rmat.b + options.rmat.c);
xscale_node = options.rmat.xscale_node;
xscale_interval = options.rmat.xscale_interval;
uint_fast32_t seed[5];
make_mrg_seed(options.rng.userseed1, options.rng.userseed2, seed);
mrg_state state;
mrg_seed(&state, seed);
//mrg_skip(&new_state, 50, 7, 0); // Do an initial skip?
edge_t total_edges = options.rmat.edges;
if((total_edges % options.rmat.xscale_interval) > options.rmat.xscale_node) {
total_edges /= options.rmat.xscale_interval;
total_edges++;
}
else {
total_edges /= options.rmat.xscale_interval;
}
if (options.global.symmetric) {
total_edges *= 2;
}
printf("Generator type: R-MAT\n");
printf("Scale: %d (%" PRIu64 " vertices)\n", options.rmat.scale, ((uint64_t)1 << options.rmat.scale));
printf("Edges: %" PRIet "\n", total_edges);
printf("Probabilities: A=%4.2f, B=%4.2f, C=%4.2f, D=%4.2f\n", options.rmat.a, options.rmat.b, options.rmat.c, d);
double start = get_time();
// io thread
size_t buffer_size = calculate_buffer_size(options.global.buffer_size);
buffer_queue flushq;
buffer_manager manager(&flushq, options.global.buffers_per_thread, buffer_size);
io_thread_func io_func(options.global.graphname.c_str(), total_edges, &flushq, &manager, buffer_size);
boost::thread io_thread(boost::ref(io_func));
// worker threads
int nthreads = options.global.nthreads;
edge_t edges_per_thread = options.rmat.edges / nthreads;
threadid_t* workers[nthreads];
boost::thread* worker_threads[nthreads];
for (int i = 0; i < nthreads; i++) {
workers[i] = new threadid_t(i);
thread_buffer* buffer = manager.register_thread(*workers[i]);
// last thread gets the remainder (if any)
edge_t start = i * edges_per_thread;
edge_t end = (i == nthreads-1) ? (options.rmat.edges) : ((i+1) * edges_per_thread);
worker_threads[i] = new boost::thread(generate, buffer,
state, options.rmat.scale, start, end,
options.rmat.a, options.rmat.b, options.rmat.c, /*d,*/
options.global.symmetric);
}
// Wait until work completes
for (int i = 0; i < nthreads; i++) {
worker_threads[i]->join();
}
io_func.stop();
io_thread.join();
// cleanup
for (int i = 0; i < nthreads; i++) {
manager.unregister_thread(*workers[i]);
delete worker_threads[i];
delete workers[i];
}
double elapsed = get_time() - start;
printf("Generation time: %fs\n", elapsed);
make_ini_file(options.global.graphname.c_str(), (uint64_t)1 << options.rmat.scale, total_edges);
return 0;
}
