home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / mach / doc / netmemory / master.c.Z / master.c
Encoding:
C/C++ Source or Header  |  1992-09-02  |  6.2 KB  |  334 lines
  1. #include <mach.h>
  2. #include <stdio.h>
  3. #include <sys/time.h>
  4.  
  5. #define    MAP_ADDR    0x50000000    
  6. char *object_name    = "netmemoryserver.test.object";
  7.  
  8. vm_offset_t
  9. map_object(size, hostname)
  10.     int size;
  11.     char *hostname;
  12. {
  13.     vm_offset_t addr;
  14.     kern_return_t kr;
  15.     char *netmemory_server_name, *getenv();
  16.     port_t netmemory_server;
  17.     port_t memory_object;
  18.     port_t netmemory_object;
  19.     port_t netmemory_control;
  20.  
  21.     /*
  22.      * Find the netmemory server.
  23.      */
  24.     netmemory_server_name = getenv("NETMEMORYSERVER_NAME");
  25.     if (! netmemory_server_name) {
  26.     netmemory_server_name = "netmemoryserver";
  27.     }
  28.     kr = netname_look_up(name_server_port, "", netmemory_server_name,
  29.              &netmemory_server);
  30.     if (kr) {
  31.     mach_error("netname_look_up(netmemoryserver)", kr);
  32.     exit(1);
  33.     }
  34.  
  35.     /*
  36.      * Slave: find the object.
  37.      * Master: create and register the object.
  38.      *
  39.      * Only the slave provides a hostname, which is the location of the object.
  40.      */
  41.     if (hostname) {
  42.     kr = netname_look_up(name_server_port, hostname, object_name,
  43.                  &netmemory_object);
  44.     if (kr) {
  45.         mach_error("netname_look_up(object)", kr);
  46.         exit(1);
  47.     }
  48.     } else {
  49.     kr = netmemory_create(netmemory_server, size, &netmemory_object,
  50.                   &netmemory_control);
  51.     if (kr) {
  52.         mach_error("netmemory_create", kr);
  53.         exit(1);
  54.     }
  55.     kr = netname_check_in(name_server_port, object_name, PORT_NULL,
  56.                   netmemory_object);
  57.     if (kr) {
  58.         mach_error("netname_check_in", kr);
  59.         netmemory_destroy(netmemory_control);
  60.         exit(1);
  61.     }
  62.     }
  63.  
  64.     /*
  65.      * Map the object.
  66.      */
  67.     kr = netmemory_cache(netmemory_server, netmemory_object, &memory_object);
  68.     if (kr) {
  69.     mach_error("netmemory_cache", kr);
  70.     exit(1);
  71.     }
  72.     if (! size) {
  73.     return (vm_offset_t) memory_object;
  74.     }
  75.     addr = MAP_ADDR;
  76.     kr = vm_map(task_self(), &addr, size, 0, FALSE, memory_object, 0, FALSE,
  77.         VM_PROT_ALL, VM_PROT_ALL, VM_INHERIT_SHARE);
  78.     if (kr) {
  79.     mach_error("vm_map", kr);
  80.     exit(1);
  81.     }
  82.     return addr;
  83. }
  84.  
  85. master_check(addr, size)
  86.     char *addr;
  87.     int size;
  88. {
  89.     int i;
  90.  
  91.     for (i = 0; i < size; i++) {
  92.     addr[i] = i % 113;
  93.     }
  94. }
  95.  
  96. slave_check(addr, size)
  97.     char *addr;
  98.     int size;
  99. {
  100.     int i;
  101.  
  102.     for (i = 0; i < size; i++) {
  103.     if (addr[i] != i % 113) {
  104.         printf("%d: %d vs %d!\n", i, addr[i], i % 113);
  105.     }
  106.     }
  107. }
  108.  
  109. #define SPIN_SWTCH    1
  110.  
  111. master_spin(addr, size)
  112.     char *addr;
  113.     int size;
  114. {
  115.     int *ip = (int *) addr;
  116.     int count = size / vm_page_size;
  117.     int i;
  118.     boolean_t verbose = (count & 01);
  119.  
  120.     for (i = 1; i <= count; i++) {
  121.     while (*ip != 0) {
  122. #if SPIN_SWTCH
  123.         swtch();
  124. #endif
  125.     }
  126.     *ip = i;
  127.     if (verbose) {
  128.         printf("%d ", i);
  129.         fflush(stdout);
  130.     }
  131.     }
  132. }
  133.  
  134. slave_spin(addr, size)
  135.     char *addr;
  136.     int size;
  137. {
  138.     int *ip = (int *) addr;
  139.     int count = size / vm_page_size;
  140.     int i;
  141.     boolean_t verbose = (count & 01);
  142.  
  143.     for (i = 1; i <= count; i++) {
  144.     while (*ip == 0) {
  145. #if SPIN_SWTCH
  146.         swtch();
  147. #endif
  148.     }
  149.     *ip = 0;
  150.     if (verbose) {
  151.         printf(". ");
  152.         fflush(stdout);
  153.     }
  154.     }
  155. }
  156.  
  157. do_read(addr, size)
  158.     char *addr;
  159.     int size;
  160. {
  161.     int i;
  162.     char c;
  163.  
  164.     for (i = 0; i < size; i += vm_page_size) {
  165.     c = addr[i];
  166.     }
  167. }
  168.  
  169. do_write(addr, size)
  170.     char *addr;
  171.     int size;
  172. {
  173.     int i;
  174.  
  175.     for (i = 0; i < size; i += vm_page_size) {
  176.     addr[i] = 1;
  177.     }
  178. }
  179.  
  180. do_null(addr, size)
  181.     char *addr;
  182.     int size;
  183. {
  184.     int i;
  185.     char c;
  186.  
  187.     for (i = 0; i < size; i += vm_page_size) {
  188.     c = (char) i;
  189.     }
  190. }
  191.  
  192. master_usage()
  193. {
  194.     fprintf(stderr,
  195.         "usage: master [spin | check | read | write | null] size(KB)\n");
  196.     exit(1);
  197. }
  198.  
  199. master(argc, argv)
  200.     int argc;
  201.     char **argv;
  202. {
  203.     char *addr;
  204.     int size, (*use)();
  205.  
  206.     if (argc != 3) {
  207.     master_usage();
  208.     }
  209.     if (! strcmp(argv[1], "spin")) {
  210.     use = master_spin;
  211.     } else if (! strcmp(argv[1], "check")) {
  212.     use = master_check;
  213.     } else if (! strcmp(argv[1], "read")) {
  214.     use = do_read;
  215.     } else if (! strcmp(argv[1], "write")) {
  216.     use = do_write;
  217.     } else if (! strcmp(argv[1], "null")) {
  218.     use = do_null;
  219.     } else {
  220.     master_usage();
  221.     }
  222.     size = 1024 * atoi(argv[2]);
  223.     size = (size + vm_page_size - 1) & ~(vm_page_size - 1);
  224.     addr = (char *) map_object(size, 0);
  225.  
  226.     printf("working... ");
  227.     fflush(stdout);
  228.  
  229.     (*use)(addr, size);
  230.  
  231.     printf("done.\n");
  232.     for (;;) {
  233.     sleep(1000000);
  234.     }
  235. }
  236.  
  237. slave_usage()
  238. {
  239.     fprintf(stderr, "usage: slave [spin | check | read | write] size(KB)\n");
  240.     exit(1);
  241. }
  242.  
  243. slave(argc, argv)
  244.     int argc;
  245.     char **argv;
  246. {
  247.     char *addr;
  248.     int size, (*use)();
  249.     struct timeval tv1, tv2;
  250.     float total;
  251.  
  252.     if (argc != 4) {
  253.     slave_usage();
  254.     }
  255.     if (! strcmp(argv[1], "spin")) {
  256.     use = slave_spin;
  257.     } else if (! strcmp(argv[1], "check")) {
  258.     use = slave_check;
  259.     } else if (! strcmp(argv[1], "read")) {
  260.     use = do_read;
  261.     } else if (! strcmp(argv[1], "write")) {
  262.     use = do_write;
  263.     } else {
  264.     slave_usage();
  265.     }
  266.     size = 1024 * atoi(argv[3]);
  267.     size = (size + vm_page_size - 1) & ~(vm_page_size - 1);
  268.     addr = (char *) map_object(size, argv[2]);
  269.  
  270.     printf("working... ");
  271.     fflush(stdout);
  272.     gettimeofday(&tv1, 0);
  273.  
  274.     (*use)(addr, size);
  275.  
  276.     gettimeofday(&tv2, 0);
  277.     printf("done.\n");
  278.     total  = 1.0      * (tv2.tv_sec  - tv1.tv_sec);
  279.     total += 0.000001 * (tv2.tv_usec - tv1.tv_usec);
  280.     printf("total_time: %.3f sec\n", total);
  281.     printf("%.3f KB/sec\n", size / 1024.0 / total);
  282.     printf("%.3f msec/msg\n", total * 1000.0 / (size / vm_page_size));
  283.     exit(0);
  284. }
  285.  
  286. stats_usage()
  287. {
  288.     fprintf(stderr, "usage: stats host [ object-name ]\n");
  289.     exit(1);
  290. }
  291.  
  292. stats(argc, argv)
  293.     int argc;
  294.     char **argv;
  295. {
  296.     port_t memory_object;
  297.     vm_offset_t addr;
  298.     vm_size_t size;
  299.  
  300.     if (argc < 2 || argc > 3) {
  301.     stats_usage();
  302.     } else if (argc == 3) {
  303.     object_name = argv[2];
  304.     }
  305.     memory_object = (port_t) map_object(0, argv[1]);
  306.     netmemory_statistics(memory_object, &addr, &size);
  307.     exit(0);
  308. }
  309.  
  310. main(argc, argv)
  311.     int argc;
  312.     char **argv;
  313. {
  314.     int len;
  315.     char *s, *a0 = argv[0];
  316.  
  317.     for (s = &a0[strlen(a0)]; s > a0; s--) {
  318.     if (*s == '/') {
  319.         s++;
  320.         break;
  321.     }
  322.     }
  323.     if (! strcmp(s, "master")) {
  324.     master(argc, argv);
  325.     } else if (! strcmp(s, "slave")) {
  326.     slave(argc, argv);
  327.     } else if (! strcmp(s, "stats")) {
  328.     stats(argc, argv);
  329.     } else {
  330.     fprintf(stderr, "usage: [master | slave] ...\n");
  331.     exit(1);
  332.     }
  333. }
  334.