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

Revision 8107a952

      * or implied, of GRNET S.A.
      */
     #define _GNU_SOURCE
     #include <stdio.h>
     #include <stdlib.h>
     #include <unistd.h>
     #include <sys/syscall.h>
     #include <sys/types.h>
     #include <pthread.h>
     #include <xseg/xseg.h>
     #include <peer.h>
     #include <time.h>
     #include <sys/util.h>
     #include <signal.h>
     struct timespec delay = {0, 4000000};
-...
     	uint64_t os; //Object size
     	uint64_t bs; //Block size
     	uint32_t iodepth; //Num of in-flight xseg reqs
     	xport dst_port;
     	uint8_t flags;
     };
     int custom_peerd_loop(struct peerd *peer);
     #define MAX_ARG_LEN 10
     void custom_peer_usage()
-...
     		"    -ts       | None    | Total I/O size\n"
     		"    -os       | 4M      | Object size\n"
     		"    -bs       | 4k      | Block size\n"
     		"    -dp       | None    | Destination port\n"
     		"    --iodepth | 1       | Number of in-flight I/O requests\n"
     		"\n");
+    }
-...
     	char block_size[MAX_ARG_LEN + 1];
     	struct xseg *xseg = peer->xseg;
     	unsigned int xseg_page_size = 1 << xseg->config.page_shift;
     	long dst_port = -1;
     	total_size[0] = 0;
     	block_size[0] = 0;
-...
     	READ_ARG_STRING("-os", object_size, MAX_ARG_LEN);
     	READ_ARG_STRING("-bs", block_size, MAX_ARG_LEN);
     	READ_ARG_ULONG("--iodepth", prefs->iodepth);
     	READ_ARG_ULONG("-dp", dst_port);
     	END_READ_ARGS();
     	/*
     	 *************************
     	 * Check size parameters *
     	 *************************
     	 */
     	//Block size (bs): Defaults to 4K.
     	//It must be a number followed by one of these characters: [k|K|m|M|g|G].
     	//If not, it will be considered as size in bytes.
-...
     		goto arg_fail;
+    	}
     	/*
     	 *************************
     	 * Check port parameters *
     	 *************************
     	 */
     	if (dst_port < 0){
     		XSEGLOG2(&lc, E, "Destination port needs to be supplied\n");
     		goto arg_fail;
+    	}
     	prefs->dst_port = (xport) dst_port;
     	/*
     	 **************************
     	 * Customize struct peerd *
     	 **************************
     	 */
     	peer->custom_peerd_loop = custom_peerd_loop;
     	peer->priv = (void *) prefs;
     	return 0;
     arg_fail:
-...
     	return -1;
+    }
     /*
      * This function substitutes the default peerd_loop of peer.c.
      * This is achieved by passing to gcc a CUSTOM_LOOP macro definition which is
      * checked (ifdef) in peer.c
      */
     int custom_peerd_loop(struct peerd *peer)
+    {
     #ifdef MT
     	int i;
     	if (peer->interactive_func)
     		peer->interactive_func();
     	for (i = 0; i < peer->nr_threads; i++) {
     		pthread_join(peer->thread[i].tid, NULL);
+    	}
     #else
     	struct xseg *xseg = peer->xseg;
     	struct bench *prefs = peer->priv;
     	xport portno_start = peer->portno_start;
     	xport portno_end = peer->portno_end;
     	uint64_t threshold=1000/(1 + portno_end - portno_start);
     	pid_t pid =syscall(SYS_gettid);
     	uint64_t loops;
     	uint64_t remaining = prefs->ts;
     	XSEGLOG2(&lc, I, "Peer has tid %u.\n", pid);
     	xseg_init_local_signal(xseg, peer->portno_start);
     	while (!isTerminate()
     			&& xq_count(&peer->free_reqs) == peer->nr_ops
     			&& remaining) {
     		for (loops= threshold; loops > 0; loops--) {
     			if (loops == 1)
     				xseg_prepare_wait(xseg, peer->portno_start);
     			if (check_ports(peer))
     				loops = threshold;
+    		}
     #ifdef ST_THREADS
     		if (ta){
     			st_sleep(0);
     			continue;
+    		}
     #endif
     		XSEGLOG2(&lc, I, "Peer goes to sleep\n");
     		xseg_wait_signal(xseg, 10000000UL);
     		xseg_cancel_wait(xseg, peer->portno_start);
     		XSEGLOG2(&lc, I, "Peer woke up\n");
+    	}
     	custom_peer_finalize(peer);
     	xseg_quit_local_signal(xseg, peer->portno_start);
     #endif
     	return 0;
+    }
     void custom_peer_finalize(struct peerd *peer)
+    {
     	return;

     	void *arg;
     };
     inline static struct thread* alloc_thread(struct peerd *peer)
+    {
     	xqindex idx = xq_pop_head(&peer->threads, 1);
-...
+    }
     #endif
     static inline int isTerminate()
     /*
      * extern is needed if this function is going to be called by another file
      * such as bench-xseg.c
      */
     inline extern int isTerminate()
+    {
     /* ta doesn't need to be taken into account, because the main loops
      * doesn't check the terminated flag if ta is not 0.
-...
     	return 0;
+    }
     static int check_ports(struct peerd *peer)
     int check_ports(struct peerd *peer)
+    {
     	struct xseg *xseg = peer->xseg;
     	xport portno_start = peer->portno_start;
-...
     	XSEGLOG2(&lc, I, "Thread %u has tid %u.\n", (unsigned int) (t- peer->thread), pid);
     	xseg_init_local_signal(xseg, peer->portno_start);
     	for (;!(isTerminate() && xq_count(&peer->free_reqs) == peer->nr_ops);) {
     		XSEGLOG("Head of loop.\n");
     		if (t->func) {
     			XSEGLOG2(&lc, D, "Thread %u executes function\n", (unsigned int) (t- peer->thread));
     			xseg_cancel_wait(xseg, peer->portno_start);
-...
     			continue;
+    		}
     		for(loops= threshold; loops > 0; loops--) {
     		for(loops =  threshold; loops > 0; loops--) {
     			if (loops == 1)
     				xseg_prepare_wait(xseg, peer->portno_start);
     			if (check_ports(peer))
-...
     	return 0;
+    }
     static int peerd_loop(struct peerd *peer)
     static int peerd_loop(struct peerd *peer)
+    {
     #ifdef MT
     	int i;
-...
     		return NULL;
+    	}
     	peer->xseg = join(spec);
     	if (!peer->xseg)
     	if (!peer->xseg)
     		return NULL;
     	peer->portno_start = (xport) portno_start;
-...
     	st_thread_t st = st_thread_create(peerd_loop, peer, 1, 0);
     	r = st_thread_join(st, NULL);
     #else
     	r = peerd_loop(peer);
     	if (peer->custom_peerd_loop)
     		r = peer->custom_peerd_loop(peer);
     	else
     		r = peerd_loop(peer);
     #endif
     out:
     	if (pid_fd > 0)

     	xport defer_portno;
     	struct peer_req *peer_reqs;
     	struct xq free_reqs;
     	int (*custom_peerd_loop)(struct peerd *peer);
     	void *priv;
     #ifdef MT
     	uint32_t nr_threads;
-...
     void get_responds_stats();
     void usage();
     void print_req(struct xseg *xseg, struct xseg_request *req);
     int isTerminate();
     int check_ports(struct peerd *peer);
     #ifdef MT
     int thread_execute(struct peerd *peer, void (*func)(void *arg), void *arg);
     #endif

Also available in: Unified diff