Archipelago

	return -1;

}

int read_pattern(char *pattern)

{

	if (strncmp(pattern, "seq", MAX_ARG_LEN + 1) == 0)

void print_stats(struct bench *prefs)

{

	if ((prefs->op == X_READ) && (GET_FLAG(VERIFY, prefs->flags) != VERIFY_NO))

		printf("Requests corrupted: %10lu\n", prefs->status->corrupted);

	printf("\n");

	remaining = prefs->status->max - prefs->status->received;

	if (remaining)

	//TODO: Add std

}

/**************************\

 * Benchmarking functions *

\**************************/

		return 0;

}

/*

 * ***********************************************

 * `create_chunk` handles 3 identifiers:

 * a) If in-flight requests are less than given iodepth

 * b) If we have submitted all of the requests

 */

void custom_peer_usage()

{

			"    --seed    | None    | Initialize LFSR and target names\n"

			"    --insanity| sane    | Adjust insanity level of benchmark:\n"

			"              |         |     [sane|eccentric|manic|paranoid]\n"

			"\n"

			"Additional information:\n"

			"  --------------------------------------------\n"

	char pattern[MAX_ARG_LEN + 1];

	char insanity[MAX_ARG_LEN + 1];

	char verify[MAX_ARG_LEN + 1];

	struct xseg *xseg = peer->xseg;

	unsigned int xseg_page_size = 1 << xseg->config.page_shift;

	long iodepth = -1;

	insanity[0] = 0;

	verify[0] = 0;

	request_cap[0] = 0;

#ifdef MT

	for (i = 0; i < nr_threads; i++) {

	READ_ARG_ULONG("--seed", seed);

	READ_ARG_STRING("--insanity", insanity, MAX_ARG_LEN);

	READ_ARG_STRING("--verify", verify, MAX_ARG_LEN);

	END_READ_ARGS();

	/*****************************\

		}

	}

	/* The request cap must be enforced only after the LFSR is initialized */

	if (request_cap[0]) {

		prefs->status->max = rc;

	}

	prefs->peer = peer;

	peer->peerd_loop = bench_peerd_loop;

	peer->priv = (void *) prefs;

	struct bench *prefs = peer->priv;

	xport portno_start = peer->portno_start;

	xport portno_end = peer->portno_end;

	pid_t pid = syscall(SYS_gettid);

	int r;

	uint64_t loops;

	XSEGLOG2(&lc, I, "%s has tid %u.\n",id, pid);

	xseg_init_local_signal(xseg, peer->portno_start);

	timer_start(prefs, prefs->total_tm);

send_request:

		while (CAN_SEND_REQUEST(prefs)) {

			xseg_cancel_wait(xseg, peer->portno_start);

			XSEGLOG2(&lc, D, "...because %lu < %lu && %lu < %lu\n",

			if (loops == 1)

				xseg_prepare_wait(xseg, peer->portno_start);

			if (check_ports(peer)) {

				//If an old request has just been acked, the most sensible

				//thing to do is to immediately send a new one

		//XSEGLOG2(&lc, I, "%s goes to sleep with %u requests pending\n",

		//		id, xq_count(q));

		XSEGLOG2(&lc, I, "%s goes to sleep\n", id);

		xseg_wait_signal(xseg, 10000000UL);

		xseg_cancel_wait(xseg, peer->portno_start);

		XSEGLOG2(&lc, I, "%s woke up\n", id);

	if (!prefs->total_tm->completed)

		timer_stop(prefs, prefs->total_tm, NULL);

	print_res(prefs, prefs->total_tm, "Total Requests");

	return;

}

#include <bench-lfsr.h>

/*

 * If CLOCK_MONOTONIC_RAW is not defined in our system, use CLOCK_MONOTONIC

 * instead. CLOCK_MONOTONIC_RAW is preferred since we are guaranteed that the

#define INSANITY_MANIC 2

#define INSANITY_PARANOID 3

/*

 * Current bench flags representation:

 * 64 7  6  5  4  3  2  1 : bits

 * ...0  0  0  0  0  0  0

 */

#define SET_FLAG(__ftype, __flag, __val)	\

/* Apply bitmask to flags, shift result to the right to get correct value */

#define GET_FLAG(__ftype, __flag)			\

	(__flag & (__ftype##_BITMASK << __ftype##_FLAG_POS)) >> __ftype##_FLAG_POS

/*

 * The benchark ID (IDLEN) is global for the test, calculated once and is a

 * string of the following form: {"bench-" + 9-digit number + "\0"}.

	uint64_t offset;

};

int bench_peerd_loop(void *arg);

void timer_start(struct bench *prefs, struct timer *sample_req);

int read_pattern(char *pattern);

int read_insanity(char *insanity);

int read_verify(char *insanity);

void print_res(struct bench *prefs, struct timer *tm, char *type);

void print_stats(struct bench *prefs);

void create_target(struct bench *prefs, struct xseg_request *req,

		uint64_t new);

void create_chunk(struct bench *prefs, struct xseg_request *req, uint64_t new);

int read_chunk(struct bench *prefs, struct xseg_request *req);

uint64_t determine_next(struct bench *prefs);

uint64_t calculate_offset(struct bench *prefs, uint64_t new);

void create_id(unsigned long seed);