bool setup_test(size_t object_size) {
    object_t* object = benchmark_object_create(object_size);
    binn root;
    bool ok;
    if (object->type == type_map) {
        binn_create_object(&root);
        ok = write_object(&root, object);
    } else {
        binn_create_list(&root);
        ok = write_list(&root, object);
    }
    object_destroy(object);

    if (!ok) {
        fprintf(stderr, "binn error writing data!\n");
        binn_free(&root);
        return false;
    }

    char filename[64];
    benchmark_filename(filename, sizeof(filename), object_size, BENCHMARK_FORMAT_BINN, NULL);
    FILE* file = fopen(filename, "wb");
    fwrite(binn_ptr(&root), binn_size(&root), 1, file);
    fclose(file);

    // like libbson, we call binn_free() regardless of whether
    // we placed it on the stack or the heap; it stores a flag
    // to say whether it should be freed. this apparently doesn't
    // cause warnings since GCC chooses not to inline binn_free().
    binn_free(&root);
    return true;
}
static bool write_object(binn* parent, object_t* object) {
    for (size_t i = 0; i < object->l; ++i) {
        char* key = CONST_CAST(object->children[i * 2].str);
        object_t* value = object->children + i * 2 + 1;
        switch (value->type) {
            case type_nil:     if (!binn_object_set_null(parent, key))                        return false;  break;
            case type_bool:    if (!binn_object_set_bool(parent, key, (BOOL)value->b))        return false;  break;
            case type_double:  if (!binn_object_set_double(parent, key, value->d))            return false;  break;
            case type_int:     if (!binn_object_set_int64(parent, key, value->i))             return false;  break;
            case type_uint:    if (!binn_object_set_uint64(parent, key, value->u))            return false;  break;
            case type_str:     if (!binn_object_set_str(parent, key, CONST_CAST(value->str))) return false;  break;

            case type_array: {
                binn child;
                binn_create_list(&child);
                bool ok = write_list(&child, value);
                if (ok)
                    ok = binn_object_set_object(parent, key, &child);
                binn_free(&child);
                if (!ok)
                    return false;
            } break;

            case type_map: {
                binn child;
                binn_create_object(&child);
                bool ok = write_object(&child, value);
                if (ok)
                    ok = binn_object_set_object(parent, key, &child);
                binn_free(&child);
                if (!ok)
                    return false;
            } break;

            default:
                return false;
        }
    }
    return true;
}
示例#3
0
int dsm_send_msg(int nodefd, dsm_message_t *msg)
{
	binn *obj;
	
	obj = binn_object();
	binn_object_set_int32(obj, DSM_MSG_KEY_TYPE, msg->type);

	switch (msg->type) {
		case CONNECT:
			binn_object_set_int32(obj, DSM_MSG_KEY_BITNESS, msg->connect_args.bitness);
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGESIZE, msg->connect_args.pagesize);
			break;
		case CONNECT_ACK:
			binn_object_set_int16(obj, DSM_MSG_KEY_BITNESS, msg->connect_ack_args.bitness_ok);
			binn_object_set_int16(obj, DSM_MSG_KEY_PAGESIZE, msg->connect_ack_args.pagesize_ok);
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGECOUNT, msg->connect_ack_args.page_count);
			break;
		case LOCKPAGE:
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGEID, msg->lockpage_args.page_id);
			binn_object_set_int16(obj, DSM_MSG_KEY_RIGHTS, msg->lockpage_args.access_rights);
			break;
		case INVALIDATE:
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGEID, msg->invalidate_args.page_id);
			break;
		case INVALIDATE_ACK:
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGEID, msg->invalidate_ack_args.page_id);
			break;
		case GIVEPAGE:
			binn_object_set_int32(obj, DSM_MSG_KEY_PAGEID, msg->givepage_args.page_id);
			binn_object_set_int16(obj, DSM_MSG_KEY_RIGHTS, msg->givepage_args.access_rights);
			binn_object_set_blob(obj, DSM_MSG_KEY_DATA, msg->givepage_args.data, dsm_g->mem->pagesize);
			break;
		case SYNC_BARRIER:
			binn_object_set_int16(obj, DSM_MSG_KEY_BARRIER, msg->sync_barrier_args.slave_to_wait);
		case BARRIER_ACK:
			break;
		case TERMINATE:
			break;
		default:
        	log("Unknown message type to send !\n");
        	return -1;
	}

	if(dsm_send(nodefd, binn_ptr(obj), binn_size(obj)) < 0) {
		log("Could not send to node %d message type: %d\n", nodefd, msg->type);
		return -1;
	}
	binn_free(obj);

	return 0;
}
示例#4
0
int dsm_receive_msg(int nodefd, dsm_message_t *msg)
{
	binn *obj;
	int blob_size;
	void* buffer;
	int buffersize;
	//char buffer[BUFFER_LEN];
	//void* ptr = (void *) &buffer;
	if(dsm_g->mem == NULL) {
		buffersize = MIN_BUFFERSIZE;
	} else {
		buffersize = MIN_BUFFERSIZE + dsm_g->mem->pagesize;
	}
	/* We cant receive a page if the mem struct isn't yet initialized anyway */

	buffer = malloc(buffersize);
	if (buffer == NULL) {
		error("Could not allocate memory (malloc)\n");
	}

	if(dsm_receive(nodefd, buffer) < 0) {
		debug("dsm_receive 0 byte, node disconnected\n");
		return -1;
	}

	obj = binn_open(buffer);

	msg->type = binn_object_int32(obj, DSM_MSG_KEY_TYPE);

	switch (msg->type) {
		case CONNECT:
			msg->connect_args.bitness = binn_object_int32(obj, DSM_MSG_KEY_BITNESS);
			msg->connect_args.pagesize = binn_object_int32(obj, DSM_MSG_KEY_PAGESIZE);
			break;
		case CONNECT_ACK:
			msg->connect_ack_args.bitness_ok = binn_object_int16(obj, DSM_MSG_KEY_BITNESS);
			msg->connect_ack_args.pagesize_ok = binn_object_int16(obj, DSM_MSG_KEY_PAGESIZE);
			msg->connect_ack_args.page_count = binn_object_int32(obj, DSM_MSG_KEY_PAGECOUNT);
			break;
		case LOCKPAGE:
			msg->lockpage_args.page_id = binn_object_int32(obj, DSM_MSG_KEY_PAGEID);
			msg->lockpage_args.access_rights = binn_object_int16(obj, DSM_MSG_KEY_RIGHTS);
			break;
		case INVALIDATE:
			msg->invalidate_args.page_id = binn_object_int32(obj, DSM_MSG_KEY_PAGEID);
			break;
		case INVALIDATE_ACK:
			msg->invalidate_ack_args.page_id = binn_object_int32(obj, DSM_MSG_KEY_PAGEID);
			break;
		case GIVEPAGE:
			msg->givepage_args.page_id = binn_object_int32(obj, DSM_MSG_KEY_PAGEID);
			msg->givepage_args.access_rights = binn_object_int16(obj, DSM_MSG_KEY_RIGHTS);
			msg->givepage_args.data = binn_object_blob(obj, DSM_MSG_KEY_DATA, &blob_size);
			break;
		case SYNC_BARRIER:
			msg->sync_barrier_args.slave_to_wait = binn_object_int16(obj, DSM_MSG_KEY_BARRIER);
			break;
		case BARRIER_ACK:
			break;
		case TERMINATE:
			break;
		default:
        	log("Unknown message type received !\n");
        	return -1;
	}

	binn_free(obj);
	free(buffer);

	return 0;
}