/ - Diff - Archipelago - Greek Research and Technology Network's projects

+    {
     	fprintf(stderr, "Custom peer options: \n"
     		"  --------------------------------------------\n"
     		"    -op       | None    | XSEG operation [read|write|info|delete]\n"
     		"    --pattern | None    | I/O pattern [sync|rand]\n"
     		"    -ts       | None    | Total I/O size\n"
     		"    -os       | 4M      | Object size\n"
     		"    -bs       | 4k      | Block size\n"
-...
     	return num;
+    }
     int read_op(char *op) {
     	if (strcmp(op, "read"))
     		return X_READ;
     	if (strcmp(op, "write"))
     		return X_WRITE;
     	if (strcmp(op, "info"))
     		return X_INFO;
     	if (strcmp(op, "delete"))
     		return X_DELETE;
     	return -1;
+    }
     int read_pattern(char *pattern) {
     	if (strcmp(pattern, "sync"))
     		return IO_SYNC;
     	if (strcmp(pattern, "rand"))
     		return IO_RAND;
     	return -1;
+    }
     int custom_peer_init(struct peerd *peer, int argc, char *argv[])
+    {
     	struct bench *prefs;
-...
     	block_size[0] = 0;
     	object_size[0] = 0;
     #ifdef MT
     	for (i = 0; i < nr_threads; i++) {
     		prefs = peer->thread[i]->priv;
     		prefs = malloc(sizeof(struct bench));
     		if (!prefs) {
     			perror("malloc");
     			return -1;
+    		}
+    	}
     #endif
     	prefs = malloc(sizeof(struct bench));
     	if (!prefs) {
     		perror("malloc");
-...
     	//Begin reading the benchmark-specific arguments
     	BEGIN_READ_ARGS(argc, argv);
     	READ_ARG_STRING("-op", op, MAX_ARG_LEN);
     	READ_ARG_STRING("--pattern", pattern, MAX_ARG_LEN);
     	READ_ARG_STRING("-ts", total_size, MAX_ARG_LEN);
     	READ_ARG_STRING("-os", object_size, MAX_ARG_LEN);
     	READ_ARG_STRING("-bs", block_size, MAX_ARG_LEN);
-...
     	READ_ARG_ULONG("-dp", dst_port);
     	END_READ_ARGS();
     	/*****************************
     	 * Check I/O type parameters *
     	 *****************************/
     	prefs->op =
     	/*************************
     	 * Check size parameters *
     	 *************************/
-...
     	 * Create timers for all metrics *
     	 *********************************/
     	prefs->total_tm = malloc(sizeof(struct timer));
     	prefs->get_tm = malloc(sizeof(struct timer));
     	prefs->sub_tm = malloc(sizeof(struct timer));
     	prefs->rec_tm = malloc(sizeof(struct timer));
     	if (!prefs->total_tm || !prefs->get_tm || !prefs->sub_tm ||
     			!prefs->rec_tm) {
     		perror("malloc");
     		return -1;
+    	}
     	memset(prefs->total_tm, 0, sizeof(struct timer));
     	memset(prefs->get_tm, 0, sizeof(struct timer));
     	memset(prefs->sub_tm, 0, sizeof(struct timer));
     	memset(prefs->rec_tm, 0, sizeof(struct timer));
     	if (init_timer(prefs->total_tm, TM_SANE))
     		goto tm_fail;
     	if (init_timer(prefs->sub_tm, TM_MANIC))
     		goto tm_fail;
     	if (init_timer(prefs->get_tm, TM_PARANOID))
     		goto tm_fail;
     	if (init_timer(prefs->rec_tm, TM_ECCENTRIC))
     		goto tm_fail;
     	/**************************
     	 * Customize struct peerd *
-...
     	return 0;
     arg_fail:
     	free(prefs);
     	custom_peer_usage();
     tm_fail:
     	free(prefs->total_tm);
     	free(prefs->sub_tm);
     	free(prefs->get_tm);
     	free(prefs->rec_tm);
     	free(prefs);
     	return -1;
+    }
-...
     	return 0;
+    }
     static void print_res(struct tm_result res, char *type)
+    {
     	printf("\n");
     	printf("      %s\n", type);
     	printf("================================\n");
     	printf("       |-s-||-ms-|-us-|-ns-|\n");
     	printf("Time:  %03lu, %03lu  %03lu  %03lu\n",
     			res.s, res.ms, res.us, res.ns);
+    }
     static void separate_by_order(struct timespec src, struct tm_result *res)
+    {
     	res->ns = src.tv_nsec % 1000;
     	src.tv_nsec /= 1000;
     	res->us = src.tv_nsec % 1000;
     	res->ms = src.tv_nsec / 1000;
     	res->s = src.tv_sec;
+    }
     void custom_peer_finalize(struct peerd *peer)
+    {
     	struct bench *prefs = peer->priv;
     	//TODO: Measure mean time, standard variation
     	struct tm_result total, mean, std;
     	unsigned int s, ms, us, ns;
     	if (!prefs->total_tm->completed)
     		timer_stop(prefs->total_tm, NULL);
     	struct timespec tm = prefs->total_tm->sum;
     	ns = tm.tv_nsec % 1000;
     	tm.tv_nsec /= 1000;
     	us = tm.tv_nsec % 1000;
     	ms = tm.tv_nsec / 1000;
     	s = tm.tv_sec;
     	printf("\n");
     	printf("          Total time spent\n");
     	printf("================================\n");
     	printf("      |-s-||-ms-|-us-|-ns-|\n");
     	printf("Time:  %03u, %03u  %03u  %03u\n", s, ms, us, ns);
     	separate_by_order(prefs->total_tm->sum, &total);
     	print_res(total, "Total Time");
     	return;
+    }

     #define MAX_ARG_LEN 10
     #define TM_SANE 0
     #define TM_ECCENTRIC 1
     #define TM_MANIC 2
     #define TM_PARANOID 3
     #define IO_SYNC 0
     #define IO_RAND 1
     struct bench {
     	uint64_t ts; //Total I/O size
     	uint64_t os; //Object size
-...
     	uint32_t iodepth; //Num of in-flight xseg reqs
     	xport dst_port;
     	xport src_port;
     	uint32_t op;	//xseg operation
     	uint8_t flags;
     	struct timer *total_tm;
     	struct timer *get_tm;
     	struct timer *sub_tm;
     	struct timer *rec_tm;
     	struct timer *total_tm; //Total time for benchmark
     	struct timer *get_tm;	//Time for xseg_get_request
     	struct timer *sub_tm;	//Time for xseg_submit_request
     	struct timer *rec_tm;	//Time for xseg_receive_request
     };
     /*
      * Custom timespec. Made to calculate variance, where we need the square of a
      * timespec structure. This structure should be more than enough to hold the
      * square of the biggest timespec.
      * timespec struct. This struct should be more than enough to hold the square
      * of the biggest timespec.
      */
     struct timespec2 {
     	unsigned long tv_sec2;
-...
     	unsigned int insanity;
     };
     struct tm_result {
     	unsigned long s;
     	unsigned long ms;
     	unsigned long us;
     	unsigned long ns;
     };
     int custom_peerd_loop(void *arg);
     void timer_start(struct timer *sample_req);

b/xseg/peers/user/peer.c
79	79	int thread_no;
80	80	void (func)(void arg);
81	81	void *arg;
	82	void *priv;
82	83	};
83	84
84	85	inline static struct thread* alloc_thread(struct peerd *peer)

     #define SEC 1000000000 //1sec = 10^9 nsec
     #define SEC2 (uint64_t) SEC*SEC //1sec*1sec = 10^18 nsec^2
     int init_timer(struct timer *tm, int insanity)
+    {
     	tm = malloc(sizeof(struct timer));
     	if (!tm) {
     		perror("malloc");
     		return -1;
+    	}
     	memset(tm, 0, sizeof(struct timer));
     	tm->insanity = insanity;
     	return 0;
+    }
     void timer_start(struct timer *timer)
+    {
     	//We need a low-latency way to get current time in nanoseconds.
-...
     	//TODO: check if we need to make it volatile
     	timer->completed++;
     	/*
     	printf("Start: %lu s %lu ns\n", start_time.tv_sec, start_time.tv_nsec);
     	printf("Elpsd: %lu s %lu ns\n", elapsed_time.tv_sec, elapsed_time.tv_nsec);
     	printf("End:   %lu s %lu ns\n", end_time.tv_sec, end_time.tv_nsec);
     	*/
+    }

Archipelago

Revision 4b114b66