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 / debug13.c < prev    next >
C/C++ Source or Header  |  2005-07-07  |  7KB  |  352 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 <pvfs2-types.h>
  11. #include <gossip.h>
  12. #include <pvfs2-debug.h>
  13.  
  14. #include <pint-distribution.h>
  15. #include <pint-dist-utils.h>
  16. #include <pvfs2-request.h>
  17. #include <pint-request.h>
  18.  
  19. #include "debug.h"
  20.  
  21. #define SEGMAX 16
  22. #define BYTEMAX (4*1024*1024)
  23.  
  24. PVFS_offset exp1_offset[] =
  25. {
  26.     0
  27. };
  28.  
  29. PVFS_size exp1_size[] =
  30. {
  31.     748
  32. };
  33.  
  34. PVFS_offset exp2_offset[] =
  35. {
  36.     20,
  37.     128,
  38.     256,
  39.      384,
  40.     544,
  41.     672,
  42.     800,
  43.     960,
  44.     1088,
  45.     1216,
  46.     3744,
  47.     3872,
  48.     4000,
  49.     4128,
  50.     4288,
  51.     4416,
  52.  
  53.     4544,
  54.     4704,
  55.     4832,
  56.     4960
  57. };
  58.  
  59. PVFS_size exp2_size[] =
  60. {
  61.     12,
  62.     32,
  63.     32,
  64.     64,
  65.     32,
  66.     32,
  67.     64,
  68.     32,
  69.     32,
  70.     32,
  71.     32,
  72.     32,
  73.     32,
  74.     64,
  75.     32,
  76.     32,
  77.  
  78.     64,
  79.     32,
  80.     32,
  81.     32
  82. };
  83.  
  84. PINT_Request_result expected[] =
  85. {{
  86.     offset_array : &exp1_offset[0],
  87.     size_array : &exp1_size[0],
  88.     segmax : SEGMAX,
  89.     segs : 1,
  90.     bytes : 748
  91. }, {
  92.     offset_array : &exp1_offset[0],
  93.     size_array : &exp1_size[0],
  94.     segmax : SEGMAX,
  95.     segs : 1,
  96.     bytes : 748
  97. }, {
  98.     offset_array : &exp2_offset[0],
  99.     size_array : &exp2_size[0],
  100.     segmax : SEGMAX,
  101.     segs : 16,
  102.     bytes : 588
  103. }, {
  104.     offset_array : &exp2_offset[16],
  105.     size_array : &exp2_size[16],
  106.     segmax : SEGMAX,
  107.     segs : 4,
  108.     bytes : 160
  109. }, {
  110.     offset_array : &exp2_offset[0],
  111.     size_array : &exp2_size[0],
  112.     segmax : SEGMAX,
  113.     segs : 16,
  114.     bytes : 588
  115. }, {
  116.     offset_array : &exp2_offset[16],
  117.     size_array : &exp2_size[16],
  118.     segmax : SEGMAX,
  119.     segs : 4,
  120.     bytes : 160
  121. }};
  122.  
  123. int request_debug(void)
  124. {
  125.     int i, r_size;
  126.     PINT_Request *r1, *r1a, *r1b, *r_packed;
  127.     PINT_Request *r2;
  128.     PINT_Request_state *rs1;
  129.     PINT_Request_state *rs1p;
  130.     PINT_Request_state *rs2;
  131.     PINT_request_file_data rf1;
  132.     PINT_Request_result seg1;
  133.  
  134.     /* PVFS_Process_request arguments */
  135.     int retval;
  136.  
  137.     /* set up request state */
  138.     PVFS_Request_vector(4, 4, 16, PVFS_DOUBLE, &r1a);
  139.     PVFS_Request_vector(3, 3, 9, r1a, &r1b);
  140.     rs1 = PINT_new_request_state(r1b);
  141.  
  142.     /* set up memory request */
  143.     PVFS_Request_contiguous(4076, PVFS_BYTE, &r2);
  144.     rs2 = PINT_new_request_state(r2);
  145.  
  146.     /* pack the request */
  147.     r_size = PINT_REQUEST_PACK_SIZE(r1b);
  148.     r_packed = (struct PINT_Request *)malloc(r_size);
  149.     PINT_request_commit(r_packed, r1b);
  150.  
  151.     PINT_request_encode(r_packed);
  152.  
  153.     r_size = PINT_REQUEST_PACK_SIZE(r_packed);
  154.     r1 = (struct PINT_Request *)malloc(r_size);
  155.     memcpy(r1, r_packed, r_size);
  156.     PINT_request_decode(r1);
  157.  
  158.     rs1p = PINT_new_request_state(r1);
  159.  
  160.     /* set up file data for request */
  161.     PINT_dist_initialize(NULL);
  162.     rf1.server_nr = 0;
  163.     rf1.server_ct = 2;
  164.     rf1.fsize = 6000;
  165.     rf1.dist = PINT_dist_create("simple_stripe");
  166.     rf1.extend_flag = 0;
  167.  
  168.     /* set up result struct */
  169.     seg1.offset_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  170.     seg1.size_array = (int64_t *)malloc(SEGMAX * sizeof(int64_t));
  171.     seg1.bytemax = BYTEMAX;
  172.     seg1.segmax = SEGMAX;
  173.     seg1.bytes = 0;
  174.     seg1.segs = 0;
  175.     
  176.     /* skip into the file datatype */
  177.     PINT_REQUEST_STATE_SET_TARGET(rs1, 20);
  178.  
  179.     PINT_REQUEST_STATE_SET_TARGET(rs1p, 20);
  180.  
  181.    /* Turn on debugging */
  182.     if (gossipflag)
  183.     {
  184.         gossip_enable_stderr();
  185.         gossip_set_debug_mask(1,GOSSIP_REQUEST_DEBUG); 
  186.     }
  187.  
  188.     i = 0;
  189.  
  190.     PINT_dump_packed_request(r_packed);
  191.  
  192.     /* skipping logical bytes */
  193.     // PINT_REQUEST_STATE_SET_TARGET(rs1,(3 * 1024) + 512);
  194.     // PINT_REQUEST_STATE_SET_FINAL(rs1,(6 * 1024) + 512);
  195.     
  196.     printf("\n************************************\n");
  197.     printf("1 request in CLIENT mode server 0 of 2\n");
  198.     printf("vector 3, 3, 9 of vector 4, 4, 16 of double\n");
  199.     printf("contig memory request of 4076 bytes\n");
  200.     printf("offset of 20 bytes, original version\n");
  201.     printf("************************************\n");
  202.     do
  203.     {
  204.         seg1.bytes = 0;
  205.         seg1.segs = 0;
  206.  
  207.         /* process request */
  208.         retval = PINT_process_request(rs1, rs2, &rf1, &seg1, PINT_CLIENT);
  209.  
  210.         if(retval >= 0)
  211.         {
  212.             prtseg(&seg1,"Results obtained");
  213.             prtseg(&expected[i],"Results expected");
  214.             cmpseg(&seg1,&expected[i]);
  215.         }
  216.  
  217.         i++;
  218.  
  219.     } while(!PINT_REQUEST_DONE(rs1) && retval >= 0);
  220.     
  221.     if(retval < 0)
  222.     {
  223.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  224.         return(-1);
  225.     }
  226.     if(PINT_REQUEST_DONE(rs1))
  227.     {
  228.         printf("**** request done.\n");
  229.     }
  230.  
  231.     PINT_REQUEST_STATE_RESET(rs2);
  232.     
  233.     printf("\n************************************\n");
  234.     printf("1 request in CLIENT mode server 0 of 2\n");
  235.     printf("vector 3, 3, 9 of vector 4, 4, 16 of double\n");
  236.     printf("contig memory request of 4076 bytes\n");
  237.     printf("offset of 20 bytes, packed then unpacked\n");
  238.     printf("************************************\n");
  239.     do
  240.     {
  241.         seg1.bytes = 0;
  242.         seg1.segs = 0;
  243.  
  244.         /* process request */
  245.         retval = PINT_process_request(rs1p, rs2, &rf1, &seg1, PINT_CLIENT);
  246.  
  247.         if(retval >= 0)
  248.         {
  249.             prtseg(&seg1,"Results obtained");
  250.             prtseg(&expected[i],"Results expected");
  251.             cmpseg(&seg1,&expected[i]);
  252.         }
  253.  
  254.         i++;
  255.  
  256.     } while(!PINT_REQUEST_DONE(rs1p) && retval >= 0);
  257.     
  258.     if(retval < 0)
  259.     {
  260.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  261.         return(-1);
  262.     }
  263.     if(PINT_REQUEST_DONE(rs1p))
  264.     {
  265.         printf("**** request done.\n");
  266.     }
  267.  
  268.     PINT_REQUEST_STATE_RESET(rs1);
  269.     PINT_REQUEST_STATE_RESET(rs2);
  270.     
  271.     printf("\n************************************\n");
  272.     printf("1 request in SERVER mode server 0 of 2\n");
  273.     printf("vector 3, 3, 9 of vector 4, 4, 16 of double\n");
  274.     printf("contig memory request of 4076 bytes\n");
  275.     printf("offset of 20 bytes, original version\n");
  276.     printf("************************************\n");
  277.     do
  278.     {
  279.         seg1.bytes = 0;
  280.         seg1.segs = 0;
  281.  
  282.         /* process request */
  283.         retval = PINT_process_request(rs1, rs2, &rf1, &seg1, PINT_SERVER);
  284.  
  285.         if(retval >= 0)
  286.         {
  287.             prtseg(&seg1,"Results obtained");
  288.             prtseg(&expected[i],"Results expected");
  289.             cmpseg(&seg1,&expected[i]);
  290.         }
  291.  
  292.         i++;
  293.  
  294.     } while(!PINT_REQUEST_DONE(rs1) && retval >= 0);
  295.     
  296.     if(retval < 0)
  297.     {
  298.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  299.         return(-1);
  300.     }
  301.     if(PINT_REQUEST_DONE(rs1))
  302.     {
  303.         printf("**** request done.\n");
  304.     }
  305.  
  306.     PINT_REQUEST_STATE_RESET(rs1p);
  307.     PINT_REQUEST_STATE_RESET(rs2);
  308.     
  309.     printf("\n************************************\n");
  310.     printf("1 request in SERVER mode server 0 of 2\n");
  311.     printf("vector 3, 3, 9 of vector 4, 4, 16 of double\n");
  312.     printf("contig memory request of 4076 bytes\n");
  313.     printf("offset of 20 bytes, packed then unpacked\n");
  314.     printf("************************************\n");
  315.     do
  316.     {
  317.         seg1.bytes = 0;
  318.         seg1.segs = 0;
  319.  
  320.         /* process request */
  321.         retval = PINT_process_request(rs1p, rs2, &rf1, &seg1, PINT_SERVER);
  322.  
  323.         if(retval >= 0)
  324.         {
  325.             prtseg(&seg1,"Results obtained");
  326.             prtseg(&expected[i],"Results expected");
  327.             cmpseg(&seg1,&expected[i]);
  328.         }
  329.  
  330.         i++;
  331.  
  332.     } while(!PINT_REQUEST_DONE(rs1p) && retval >= 0);
  333.     
  334.     if(retval < 0)
  335.     {
  336.         fprintf(stderr, "Error: PINT_process_request() failure.\n");
  337.         return(-1);
  338.     }
  339.     if(PINT_REQUEST_DONE(rs1p))
  340.     {
  341.         printf("**** request done.\n");
  342.     }
  343.  
  344.     PVFS_Request_free(&r1);
  345.     PVFS_Request_free(&r1a);
  346.     PVFS_Request_free(&r1b);
  347.     PVFS_Request_free(&r2);
  348.     PVFS_Request_free(&r_packed);
  349.  
  350.     return 0;
  351. }
  352.