home *** CD-ROM | disk | FTP | other *** search
/ ftp.parl.clemson.edu / 2015-02-07.ftp.parl.clemson.edu.tar / ftp.parl.clemson.edu / pub / pvfs2 / orangefs-2.8.3-20110323.tar.gz / orangefs-2.8.3-20110323.tar / orangefs / test / io / description / test-encode-complex-out.c < prev    next >
C/C++ Source or Header  |  2005-11-11  |  4KB  |  178 lines
  1. /*
  2.  * (C) 2002 Clemson University.
  3.  *
  4.  * See COPYING in top-level directory.
  5.  */       
  6.  
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <assert.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <fcntl.h>
  14. #include <unistd.h>
  15.  
  16. #include <pvfs2-types.h>
  17. #include <gossip.h>
  18. #include <pvfs2-debug.h>
  19. #include <pint-distribution.h>
  20. #include <pint-dist-utils.h>
  21. #include <pvfs2-request.h>
  22. #include <pint-request.h>
  23. #include "pvfs2-internal.h"
  24.  
  25. #define SEGMAX 16
  26. #define BYTEMAX (1024*1024)
  27.  
  28. void Dump_request(PVFS_Request req);
  29.  
  30. int main(int argc, char **argv)
  31. {
  32.     PINT_Request *r;
  33.     PINT_Request *r1;
  34.     PINT_Request *r_enc;
  35.     int ret = -1;
  36.     int pack_size = 0;
  37.     int fd = -1;
  38.     PINT_Request_state *rs1;
  39.     PINT_request_file_data rf1;
  40.     PINT_Request_result seg1;
  41.     int retval;
  42.     int i;
  43.     int count = 64;
  44.     int32_t* len_array;
  45.     PVFS_offset* disp_array;
  46.  
  47.     len_array = (int32_t*)malloc(count*sizeof(int32_t));
  48.     assert(len_array);
  49.     disp_array = (PVFS_offset*)malloc(count*sizeof(PVFS_offset));
  50.     assert(disp_array);
  51.  
  52.     for(i=0; i<count; i++)
  53.     {
  54.         len_array[i] = 4;
  55.         disp_array[i] = i*8;
  56.     }
  57.  
  58.     fd = open("enc_tmp.dat", O_WRONLY|O_CREAT|O_TRUNC, S_IRWXU);
  59.     if(fd < 0)
  60.     {
  61.         perror("open");
  62.         return(-1);
  63.     }
  64.     
  65.     r = PVFS_BYTE;
  66.  
  67.     PVFS_Request_hindexed(64, len_array, disp_array, r, &r1);
  68.  
  69.     /* set up request state */
  70.     rs1 = PINT_new_request_state(r1);
  71.  
  72.     /* set up file data for request */
  73.     PINT_dist_initialize(NULL);
  74.     rf1.server_nr = 0;
  75.     rf1.server_ct = 4;
  76.     rf1.fsize = 6000;
  77.     rf1.dist = PINT_dist_create("simple_stripe");
  78.     rf1.extend_flag = 0;
  79.     PINT_dist_lookup(rf1.dist);
  80.  
  81.     /* set up result struct */
  82.     seg1.offset_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  83.     seg1.size_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  84.     seg1.bytemax = BYTEMAX;
  85.     seg1.segmax = SEGMAX;
  86.     seg1.bytes = 0;
  87.     seg1.segs = 0;
  88.         
  89.     printf("\n************************************\n");
  90.     do
  91.     {
  92.         seg1.bytes = 0;
  93.         seg1.segs = 0;
  94.  
  95.         /* process request */
  96.         retval = PINT_process_request(rs1, NULL, &rf1, &seg1, PINT_CLIENT);
  97.  
  98.         if(retval >= 0)
  99.         {
  100.             printf("results of PINT_process_request():\n");
  101.             printf("%d segments with %lld bytes\n", seg1.segs, lld(seg1.bytes));
  102.             for(i=0; i<seg1.segs; i++)
  103.             {
  104.                 printf("  segment %d: offset: %d size: %d\n",
  105.                     i, (int)seg1.offset_array[i], (int)seg1.size_array[i]);
  106.             }
  107.         }
  108.  
  109.     } while(!PINT_REQUEST_DONE(rs1) && retval >= 0);
  110.     
  111.     if(retval < 0)
  112.     {
  113.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  114.         return(-1);
  115.     }
  116.     if(PINT_REQUEST_DONE(rs1))
  117.     {
  118.         printf("**** request done.\n");
  119.     }
  120.  
  121.  
  122.     
  123.  
  124.     /* allocate a new request and pack the original one into it */
  125.     pack_size = PINT_REQUEST_PACK_SIZE(r1);
  126.     fprintf(stderr, "pack size is %d\n",pack_size);
  127.     r_enc = (PINT_Request*)malloc(pack_size);
  128.     assert(r_enc != NULL);
  129.  
  130.     ret = PINT_request_commit(r_enc, r1);
  131.     if(ret < 0)
  132.     {
  133.         fprintf(stderr, "PINT_Request_commit() failure.\n");
  134.         return(-1);
  135.     }
  136.     fprintf(stderr, "commit returns %d\n", ret);
  137.     ret = PINT_request_encode(r_enc);
  138.     if(ret < 0)
  139.     {
  140.         fprintf(stderr, "PINT_Request_encode() failure.\n");
  141.         return(-1);
  142.     }
  143.     fprintf(stderr, "encode returns %d\n", ret);
  144.  
  145.     ret = write(fd, r_enc, pack_size);
  146.     if(ret < 0)
  147.     {
  148.         perror("write");
  149.         return(-1);
  150.     }
  151.  
  152.     close(fd);
  153.  
  154.     return 0;
  155. }
  156.  
  157. void Dump_request(PVFS_Request req)
  158. {
  159.     fprintf(stderr,"**********************\n");
  160.     fprintf(stderr,"address:\t%p\n",req);
  161.     fprintf(stderr,"offset:\t\t%d\n",(int)req->offset);
  162.     fprintf(stderr,"num_ereqs:\t%d\n",(int)req->num_ereqs);
  163.     fprintf(stderr,"num_blocks:\t%d\n",(int)req->num_blocks);
  164.     fprintf(stderr,"stride:\t\t%d\n",(int)req->stride);
  165.     fprintf(stderr,"ub:\t\t%d\n",(int)req->ub);
  166.     fprintf(stderr,"lb:\t\t%d\n",(int)req->lb);
  167.     fprintf(stderr,"agg_size:\t%d\n",(int)req->aggregate_size);
  168.     fprintf(stderr,"num_chunk:\t%d\n",(int)req->num_contig_chunks);
  169.     fprintf(stderr,"depth:\t\t%d\n",(int)req->depth);
  170.     fprintf(stderr,"num_nest:\t%d\n",(int)req->num_nested_req);
  171.     fprintf(stderr,"commit:\t\t%d\n",(int)req->committed);
  172.     fprintf(stderr,"refcount:\t\t%d\n",(int)req->refcount);
  173.     fprintf(stderr,"ereq:\t\t%p\n",req->ereq);
  174.     fprintf(stderr,"sreq:\t\t%p\n",req->sreq);
  175.     fprintf(stderr,"**********************\n");
  176. }
  177.  
  178.