[ipbench-cvs] ipbench2/src/tests/nfs_latency nfs_glue.c,1.5,1.6

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/ipbench/ipbench2/src/tests/nfs_latency
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv16916

Modified Files:
	nfs_glue.c 
Log Message:
re-structure to pre-generate workload during initialisation

Index: nfs_glue.c
===================================================================
RCS file: /cvsroot/ipbench/ipbench2/src/tests/nfs_latency/nfs_glue.c,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** nfs_glue.c	13 Sep 2005 04:04:15 -0000	1.5
--- nfs_glue.c	14 Sep 2005 02:39:45 -0000	1.6
***************
*** 22,96 ****
  static struct cookie nfs_file_handle;

! int resolve(char *name, struct sockaddr_in *sock){
! 	struct hostent *hp;
! 
! 	if((hp = gethostbyname(name))==NULL)
! 		return -1;
! 
! 	memset(sock, 0, sizeof(struct sockaddr_in));
! 	memcpy(&sock->sin_addr, hp->h_addr, hp->h_length);
! 
! 	assert(hp->h_addrtype == PF_INET);
! 
! 	sock->sin_family = PF_INET;
! 	sock->sin_port = htons(0);
! 
! 	return 0;
! }
! 
! static void
! open_cb(uintptr_t token, int status, struct cookie *fh, fattr_t *pattrs){
! 	static int idem = 0;
! 
! 	assert(idem==0);
! 	idem = 1;
! 
! 	if(status==NFS_OK){
! 		nfs_file_handle = *fh;
! 		initialised = 1;
! 	}else{
! 		initialised = -1;
! 	}
! 
! 	return;
! }
! 
! int
! init_and_open(char *hostname, char *mountpoint, char *filename){
! 	struct sockaddr_in addr;
! 	struct cookie pfh;
! 
! 	microuptime_calibrate();
! 
! 	if(resolve(hostname, &addr) < 0){
! 		printf("error resolving \"%s\"\n", hostname);
! 		exit(-1);
! 	}
! 
! 	/* XXX these should be dynamically controlled */
! 	callback_init(10,100000);
! 
! 	map_init(&addr);
! 	mnt_init(&addr);
! 	nfs_init(&addr);
! 
! 	mnt_get_export_list();
! 	mnt_mount(mountpoint, &pfh);
! 	nfs_lookup(&pfh, filename, open_cb, 0);
! 
! 	while(initialised==0){
! 		struct pbuf buf;
! 		rpc_recv(&buf, nfs_fd, -1);
! 	}

! 	if(initialised < 0){
! 		return -1;
! 	}

! 	return 0;
! }

! #define READ_OFFSET 0
! #define READ_SIZE 1024

  uint64_t last_sample = 0;
--- 22,44 ----
  static struct cookie nfs_file_handle;

! #define READ_OFFSET 0
! #define READ_SIZE 1024

! struct read_request{
! 	struct pbuf pbuf;
! };

! struct write_request{
! 	struct pbuf pbuf;
! 	uint8_t data[READ_SIZE];
! };

! struct nfs_request{
! 	void (*callback)(struct callback *c, struct pbuf *pbuf);
! 	union{
! 		struct read_request r;
! 		struct write_request w;
! 	} *request;
! } *nfs_cache = NULL;

  uint64_t last_sample = 0;
***************
*** 106,148 ****
  }

- struct read_request{
- 	struct pbuf pbuf;
- };
- 
  /*
   * instead of using nfs_read(), we generate ourselves a read with a 
   * special timing callback.
   */
! static int
! generate_read_request(uint64_t timestamp){
! 	static struct read_request *rr = NULL;
! 	struct callback c;
! 
! 	if(rr==NULL){
! 		/* initialise write request */
! 		readargs_t args;

! 		rr = malloc(sizeof(struct read_request));
! 		assert(rr!=NULL);

! 		/* set up buffer */
! 		initbuf(&rr->pbuf, NFS_NUMBER, NFS_VERSION, NFSPROC_READ);

! 		args.file = nfs_file_handle;
! 		args.offset = READ_OFFSET;
! 		args.count = READ_SIZE;
! 		args.totalcount = 0; /* unused as per RFC */

! 		addtobuf(&rr->pbuf, &args, sizeof(args), 1);
! 	}else{
! 		/* just set a new xid */
! 		reset_xid(rr->pbuf.buf);
! 	}

! 	/* set up callback */
! 	c.func = read_callback;
! 	c.param.time.timestamp = timestamp;

! 	return rpc_send(&rr->pbuf, nfs_fd, &c);
  }

--- 54,83 ----
  }

  /*
   * instead of using nfs_read(), we generate ourselves a read with a 
   * special timing callback.
   */
! static struct nfs_request
! create_read_request(){
! 	struct nfs_request rr;
! 	readargs_t args;

! 	/* initialise read request */
! 	rr.request = malloc(sizeof(struct read_request));
! 	assert(rr.request!=NULL);

! 	/* set up buffer */
! 	initbuf(&rr.request->r.pbuf, NFS_NUMBER, NFS_VERSION, NFSPROC_READ);

! 	args.file = nfs_file_handle;
! 	args.offset = READ_OFFSET;
! 	args.count = READ_SIZE;
! 	args.totalcount = 0; /* unused as per RFC */

! 	addtobuf(&rr.request->r.pbuf, &args, sizeof(args), 1);

! 	rr.callback = read_callback;

! 	return rr;
  }

***************
*** 157,208 ****
  }

- struct write_request{
- 	struct pbuf pbuf;
- 	uint8_t data[READ_SIZE];
- };
- 
  /*
   * instead of using nfs_write(), we generate ourselves a read with a 
   * special timing callback.
   */
! static int
! generate_write_request(uint64_t timestamp){
! 	static struct write_request *wr = NULL;
! 	struct callback c;

! 	if(wr==NULL){
! 		/* initialise write request */
! 		int i;
! 		writeargs_t args;

- 		wr = malloc(sizeof(struct write_request));
- 		assert(wr!=NULL);

! 		printf("generating write data...\n");
! 		for(i=0; i<READ_SIZE; i++){
! 			wr->data[i] = (uint8_t)(random() & 0xFF);
! 		}
! 		printf("generating write data done.\n");

! 		/* set up buffer */
! 		initbuf(&wr->pbuf, NFS_NUMBER, NFS_VERSION, NFSPROC_WRITE);

! 		args.file = nfs_file_handle;
! 		args.offset = READ_OFFSET;
! 		args.beginoffset = 0; /* unused as per RFC */
! 		args.totalcount = 0;  /* unused as per RFC */

! 		addtobuf(&wr->pbuf, &args, sizeof(args), 1);
! 		adddata(&wr->pbuf, wr->data, READ_SIZE, 0);
! 	}else{
! 		/* just set a new xid */
! 		reset_xid(wr->pbuf.buf);
! 	}

! 	/* set up callback */
! 	c.func = write_callback;
! 	c.param.time.timestamp = timestamp;

! 	return rpc_send(&wr->pbuf, nfs_fd, &c);
  }

--- 92,144 ----
  }

  /*
   * instead of using nfs_write(), we generate ourselves a read with a 
   * special timing callback.
   */
! static struct nfs_request
! create_write_request(){
! 	struct nfs_request wr;
! 	int i;
! 	writeargs_t args;

! 	/* initialise write request */
! 	wr.request = malloc(sizeof(struct write_request));
! 	assert(wr.request!=NULL);

! 	printf("generating write data...\n");
! 	for(i=0; i<READ_SIZE; i++){
! 		wr.request->w.data[i] = (uint8_t)(random() & 0xFF);
! 	}
! 	printf("generating write data done.\n");

! 	/* set up buffer */
! 	initbuf(&wr.request->w.pbuf, NFS_NUMBER, NFS_VERSION, NFSPROC_WRITE);

! 	args.file = nfs_file_handle;
! 	args.offset = READ_OFFSET;
! 	args.beginoffset = 0; /* unused as per RFC */
! 	args.totalcount = 0;  /* unused as per RFC */

! 	addtobuf(&wr.request->w.pbuf, &args, sizeof(args), 1);
! 	/* XXX why is data sticking around once encoded? */
! 	adddata(&wr.request->w.pbuf, wr.request->w.data, READ_SIZE, 0);

! 	wr.callback = write_callback;

! 	return wr;
! }
! 
! int
! initialise_cache(){
! 	assert(nfs_cache==NULL);
! 
! 	nfs_cache = malloc(sizeof(struct nfs_request)*2);
! 	assert(nfs_cache!=NULL);
! 
! 	nfs_cache[0] = create_read_request();
! 	nfs_cache[1] = create_write_request();
! 
! 	return 0;
  }

***************
*** 212,228 ****
  int
  generate_request(uint64_t timestamp){
  	assert(initialised==1);

! 	//switch(random()&1){
! 	switch(1){
! 		case 0:
! 			return generate_read_request(timestamp);
! 		case 1:
! 			return generate_write_request(timestamp);
! 	}

! 	assert(!"should not get here\n");

! 	return -1;
  }

--- 148,168 ----
  int
  generate_request(uint64_t timestamp){
+ 	struct callback c;
+ 	int i;
+ 
  	assert(initialised==1);

! 	/* pick a random cache entry */
! 	//i = 0;
! 	i = random()&1;

! 	/* set a new xid */
! 	reset_xid(nfs_cache[i].request->r.pbuf.buf);

! 	/* set up callback */
! 	c.func = nfs_cache[i].callback;
! 	c.param.time.timestamp = timestamp;
! 
! 	return rpc_send(&nfs_cache[i].request->r.pbuf, nfs_fd, &c);
  }

***************
*** 244,245 ****
--- 184,256 ----
  	return 0;
  }
+ 
+ int resolve(char *name, struct sockaddr_in *sock){
+ 	struct hostent *hp;
+ 
+ 	if((hp = gethostbyname(name))==NULL)
+ 		return -1;
+ 
+ 	memset(sock, 0, sizeof(struct sockaddr_in));
+ 	memcpy(&sock->sin_addr, hp->h_addr, hp->h_length);
+ 
+ 	assert(hp->h_addrtype == PF_INET);
+ 
+ 	sock->sin_family = PF_INET;
+ 	sock->sin_port = htons(0);
+ 
+ 	return 0;
+ }
+ 
+ static void
+ open_cb(uintptr_t token, int status, struct cookie *fh, fattr_t *pattrs){
+ 	static int idem = 0;
+ 
+ 	assert(idem==0);
+ 	idem = 1;
+ 
+ 	if(status==NFS_OK){
+ 		nfs_file_handle = *fh;
+ 		initialised = 1;
+ 	}else{
+ 		initialised = -1;
+ 	}
+ 
+ 	return;
+ }
+ 
+ int
+ init_and_open(char *hostname, char *mountpoint, char *filename){
+ 	struct sockaddr_in addr;
+ 	struct cookie pfh;
+ 
+ 	microuptime_calibrate();
+ 
+ 	if(resolve(hostname, &addr) < 0){
+ 		printf("error resolving \"%s\"\n", hostname);
+ 		exit(-1);
+ 	}
+ 
+ 	/* XXX these should be dynamically controlled */
+ 	callback_init(10,100000);
+ 
+ 	map_init(&addr);
+ 	mnt_init(&addr);
+ 	nfs_init(&addr);
+ 
+ 	mnt_get_export_list();
+ 	mnt_mount(mountpoint, &pfh);
+ 	nfs_lookup(&pfh, filename, open_cb, 0);
+ 
+ 	while(initialised==0){
+ 		struct pbuf buf;
+ 		rpc_recv(&buf, nfs_fd, -1);
+ 	}
+ 
+ 	if(initialised < 0){
+ 		return -1;
+ 	}
+ 
+ 	initialise_cache();
+ 
+ 	return 0;
+ }

[ipbench-cvs] ipbench2/src/tests/nfs_latency nfs_glue.c,1.5,1.6

A benchmark suite for reliable testing of IP networks.

[ipbench-cvs] ipbench2/src/tests/nfs_latency nfs_glue.c,1.5,1.6