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 / debug9.c < prev    next >
C/C++ Source or Header  |  2005-07-07  |  4KB  |  227 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 <pvfs2-types.h>
  10. #include <gossip.h>
  11. #include <pvfs2-debug.h>
  12.  
  13. #include <pint-distribution.h>
  14. #include <pint-dist-utils.h>
  15. #include <pvfs2-request.h>
  16. #include <pint-request.h>
  17.  
  18. #include <debug.h>
  19.  
  20. #define SEGMAX 16
  21. #define BYTEMAX (4*1024*1024)
  22.  
  23. PVFS_offset exp1_offset [] = {
  24.     0 ,
  25.     384 ,
  26.     768 ,
  27.     1152 ,
  28.     1536 ,
  29.     1920 ,
  30.     2304 ,
  31.     2688 ,
  32.     3072 ,
  33.     3456 ,
  34.     3840 ,
  35.     4224 ,
  36.     4608 ,
  37.     4992 ,
  38.     5376 ,
  39.     5760 
  40. };
  41.  
  42. PVFS_offset exp2_offset [] = {
  43.     6144 ,
  44.     6528 ,
  45.     6912 ,
  46.     7296 ,
  47.     7680 ,
  48.     8064 ,
  49.     8448 ,
  50.     8832 ,
  51.     9216 ,
  52.     9600 ,
  53.     9984 ,
  54.     10368 ,
  55.     10752 ,
  56.     11136 ,
  57.     11520 ,
  58.     11904 
  59. };
  60.  
  61. PVFS_offset exp3_offset [] = {
  62.     12288 ,
  63.     12672 ,
  64.     13056 ,
  65.     13440 ,
  66.     13824 ,
  67.     14208 ,
  68.     14592 ,
  69.     14976 ,
  70.     15360 ,
  71.     15744 ,
  72.     16128 ,
  73.     16512 ,
  74.     16896 ,
  75.     17280 ,
  76.     17664 ,
  77.     18048 
  78. };
  79.  
  80. PVFS_offset exp4_offset [] = {
  81.     18432 ,
  82.     18816 ,
  83.     19200 ,
  84.     19584 ,
  85.     19968 ,
  86.     20352 ,
  87.     20736 ,
  88.     21120 
  89. };
  90.  
  91. PVFS_size exp1_size [] = {
  92.     128,
  93.     128,
  94.     128,
  95.     128,
  96.     128,
  97.     128,
  98.     128,
  99.     128,
  100.     128,
  101.     128,
  102.     128,
  103.     128,
  104.     128,
  105.     128,
  106.     128,
  107.     128
  108. };
  109.  
  110. PINT_Request_result expected[] =
  111. {{
  112.    offset_array : &exp1_offset[0],
  113.    size_array : &exp1_size[0],
  114.    segmax : SEGMAX,
  115.    segs : 16,
  116.    bytes : 16*128
  117. }, {
  118.    offset_array : &exp2_offset[0],
  119.    size_array : &exp1_size[0],
  120.    segmax : SEGMAX,
  121.    segs : 16,
  122.    bytes : 16*128
  123. }, {
  124.    offset_array : &exp3_offset[0],
  125.    size_array : &exp1_size[0],
  126.    segmax : SEGMAX,
  127.    segs : 16,
  128.    bytes : 16*128
  129. }, {
  130.    offset_array : &exp4_offset[0],
  131.    size_array : &exp1_size[0],
  132.    segmax : SEGMAX,
  133.    segs : 8,
  134.    bytes : 8*128
  135. }};
  136.  
  137. int request_debug(void)
  138. {
  139.     int i;
  140.     PINT_Request *r1;
  141.     PINT_Request *r2;
  142.     PINT_Request_state *rs1;
  143.     PINT_Request_state *rs2;
  144.     PINT_request_file_data rf1;
  145.     PINT_Request_result seg1;
  146.  
  147.     /* PVFS_Process_request arguments */
  148.     int retval;
  149.  
  150.     /* set up request */
  151.     PVFS_Request_vector(20, 1024, 20*1024, PVFS_BYTE, &r1);
  152.  
  153.     /* set up request state */
  154.     rs1 = PINT_new_request_state(r1);
  155.  
  156.     /* set up memory request */
  157.     PVFS_Request_vector(160, 128, 3*128, PVFS_BYTE, &r2);
  158.     rs2 = PINT_new_request_state(r2);
  159.  
  160.     /* set up file data for request */
  161.     PINT_dist_initialize(NULL);
  162.     rf1.server_nr = 0;
  163.     rf1.server_ct = 4;
  164.     rf1.fsize = 10000000;
  165.     rf1.dist = PINT_dist_create("simple_stripe");
  166.     rf1.extend_flag = 1;
  167.     PINT_dist_lookup(rf1.dist);
  168.  
  169.     /* set up result struct */
  170.     seg1.offset_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  171.     seg1.size_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  172.     seg1.bytemax = BYTEMAX;
  173.     seg1.segmax = SEGMAX;
  174.     seg1.bytes = 0;
  175.     seg1.segs = 0;
  176.  
  177.    /* Turn on debugging */
  178.     if (gossipflag)
  179.     {
  180.         gossip_enable_stderr();
  181.         gossip_set_debug_mask(1,GOSSIP_REQUEST_DEBUG);
  182.     }
  183.  
  184.     i = 0;
  185.  
  186.     /* skipping logical bytes */
  187.     // PINT_REQUEST_STATE_SET_TARGET(rs1,(3 * 1024) + 512);
  188.     // PINT_REQUEST_STATE_SET_FINAL(rs1,(6 * 1024) + 512);
  189.     
  190.     printf("\n************************************\n");
  191.     printf("One request in CLIENT mode size 20*1K strided 20K server 0 of 4\n");
  192.     printf("Simple stripe, default stripe size (64K)\n");
  193.     printf("Offset 0M, file size 10000000, extend flag\n");
  194.     printf("MemReq size 160*128 strided 3*128\n");
  195.     printf("\n************************************\n");
  196.     do
  197.     {
  198.         seg1.bytes = 0;
  199.         seg1.segs = 0;
  200.  
  201.         /* process request */
  202.         retval = PINT_process_request(rs1, rs2, &rf1, &seg1, PINT_CLIENT);
  203.  
  204.         if(retval >= 0)
  205.         {
  206.             prtseg(&seg1,"Results obtained");
  207.             prtseg(&expected[i],"Results expected");
  208.             cmpseg(&seg1,&expected[i]);
  209.         }
  210.  
  211.         i++;
  212.  
  213.     } while(!PINT_REQUEST_DONE(rs1) && retval >= 0);
  214.     
  215.     if(retval < 0)
  216.     {
  217.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  218.         return(-1);
  219.     }
  220.     if(PINT_REQUEST_DONE(rs1))
  221.     {
  222.         printf("**** request done.\n");
  223.     }
  224.  
  225.     return 0;
  226. }
  227.