ipbench-cvs

[Luke M. <lu...@us...>]

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

Modified Files:
	nfs_glue.c 
Log Message:
pre-generate nfs requests


Index: nfs_glue.c
===================================================================
RCS file: /cvsroot/ipbench/ipbench2/src/tests/nfs_latency/nfs_glue.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** nfs_glue.c	22 Aug 2005 23:55:51 -0000	1.4
--- nfs_glue.c	13 Sep 2005 04:04:15 -0000	1.5
***************
*** 106,109 ****
--- 106,113 ----
  }
  
+ struct read_request{
+ 	struct pbuf pbuf;
+ };
+ 
  /*
   * instead of using nfs_read(), we generate ourselves a read with a 
***************
*** 112,118 ****
  static int
  generate_read_request(uint64_t timestamp){
! 	struct pbuf pbuf;
  	struct callback c;
! 	readargs_t args;
  
  	/* set up callback */
--- 116,142 ----
  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 */
***************
*** 120,134 ****
  	c.param.time.timestamp = timestamp;
  
! 	/* set up buffer */
! 	initbuf(&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(&pbuf, &args, sizeof(args), 1);
  
! 	return rpc_send(&pbuf, nfs_fd, &c);
  }
  
--- 144,208 ----
  	c.param.time.timestamp = timestamp;
  
! 	return rpc_send(&rr->pbuf, nfs_fd, &c);
! }
  
! static void
! write_callback(struct callback *c, struct pbuf *pbuf){
! 	assert(c->func==write_callback);
! 	assert(last_sample==0);
  
! 	/* XXX we should really check the NFS error code here */
  
! 	last_sample = c->param.time.timestamp;
! }
! 
! 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);
  }
  
***************
*** 139,143 ****
  generate_request(uint64_t timestamp){
  	assert(initialised==1);
! 	return generate_read_request(timestamp);
  }
  
--- 213,228 ----
  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;
  }