netwerk/test/TestPerf.cpp

   1 #include "TestCommon.h"
   2 #include <stdio.h>
   3 #include "nsCRT.h" /* should be "plstr.h"? */
   4 #include "nsNetUtil.h"
   5 #include "nsIServiceManager.h"
   6 #include "nsIComponentRegistrar.h"
   7 #include "nsISupportsArray.h"
   8
   9 namespace TestPerf {
  10
  11 static nsIIOService *gIOService = nsnull;
  12
  13 //-----------------------------------------------------------------------------
  14
  15 static PRBool
  16 load_sync_1(nsISupports *element, void *data)
  17 {
  18     nsCOMPtr<nsIInputStream> stream;
  19     nsCOMPtr<nsIURI> uri( do_QueryInterface(element) );
  20     nsCAutoString spec;
  21     nsresult rv;
  22
  23     rv = NS_OpenURI(getter_AddRefs(stream), uri, gIOService);
  24     if (NS_FAILED(rv)) {
  25         uri->GetAsciiSpec(spec);
  26         fprintf(stderr, "*** failed opening %s [rv=%x]\n", spec.get(), rv);
  27         return PR_TRUE;
  28     }
  29
  30     char buf[4096];
  31     PRUint32 bytesRead;
  32
  33     while (1) {
  34         rv = stream->Read(buf, sizeof(buf), &bytesRead);
  35         if (NS_FAILED(rv) || bytesRead == 0) {
  36             if (NS_FAILED(rv)) {
  37                 uri->GetAsciiSpec(spec);
  38                 fprintf(stderr, "*** failed reading %s [rv=%x]\n", spec.get(), rv);
  39             }
  40             break;
  41         }
  42     }
  43
  44     return PR_TRUE;
  45 }
  46
  47 static nsresult
  48 load_sync(nsISupportsArray *urls)
  49 {
  50     urls->EnumerateForwards(load_sync_1, nsnull);
  51     return NS_OK;
  52 }
  53
  54 //-----------------------------------------------------------------------------
  55
  56 static int gRequestCount = 0;
  57
  58 class MyListener : public nsIStreamListener
  59 {
  60 public:
  61     NS_DECL_ISUPPORTS
  62     NS_DECL_NSIREQUESTOBSERVER
  63     NS_DECL_NSISTREAMLISTENER
  64
  65     MyListener() { }
  66     virtual ~MyListener() {}
  67 };
  68
  69 NS_IMPL_ISUPPORTS2(MyListener, nsIStreamListener, nsIRequestObserver)
  70
  71 NS_IMETHODIMP
  72 MyListener::OnStartRequest(nsIRequest *req, nsISupports *ctx)
  73 {
  74     return NS_OK;
  75 }
  76
  77 NS_IMETHODIMP
  78 MyListener::OnDataAvailable(nsIRequest *req, nsISupports *ctx,
  79                             nsIInputStream *stream,
  80                             PRUint32 offset, PRUint32 count)
  81 {
  82     nsresult rv;
  83     char buf[4096];
  84     PRUint32 n, bytesRead;
  85     while (count) {
  86         n = PR_MIN(count, sizeof(buf));
  87         rv = stream->Read(buf, n, &bytesRead);
  88         if (NS_FAILED(rv))
  89             break;
  90         count -= bytesRead;
  91         if (bytesRead == 0)
  92             break;
  93     }
  94     return NS_OK;
  95 }
  96
  97 NS_IMETHODIMP
  98 MyListener::OnStopRequest(nsIRequest *req, nsISupports *ctx, nsresult status)
  99 {
 100     if (NS_FAILED(status)) {
 101         nsCAutoString spec;
 102         req->GetName(spec);
 103         fprintf(stderr, "*** failed loading %s [reason=%x]\n", spec.get(), status);
 104     }
 105     if (--gRequestCount == 0) {
 106         // post shutdown event
 107         QuitPumpingEvents();
 108     }
 109     return NS_OK;
 110 }
 111
 112 static PRBool
 113 load_async_1(nsISupports *element, void *data)
 114 {
 115     nsCOMPtr<nsIURI> uri( do_QueryInterface(element) );
 116     if (!uri)
 117         return PR_TRUE;
 118
 119     MyListener *listener = new MyListener();
 120     if (!listener)
 121         return PR_TRUE;
 122     NS_ADDREF(listener);
 123     nsresult rv = NS_OpenURI(listener, nsnull, uri, gIOService);
 124     NS_RELEASE(listener);
 125     if (NS_SUCCEEDED(rv))
 126         gRequestCount++;
 127     else
 128         printf(">> NS_OpenURI failed [rv=%x]\n", rv);
 129     return PR_TRUE;
 130 }
 131
 132 static nsresult
 133 load_async(nsISupportsArray *urls)
 134 {
 135     urls->EnumerateForwards(load_async_1, nsnull);
 136
 137     PumpEvents();
 138     return NS_OK;
 139 }
 140
 141 //-----------------------------------------------------------------------------
 142
 143 static nsresult
 144 read_file(const char *fname, nsISupportsArray *urls)
 145 {
 146     FILE *fp = fopen(fname, "r");
 147     if (!fp) {
 148         printf("failed opening file: %s\n", fname);
 149         return NS_ERROR_FAILURE;
 150     }
 151
 152     nsCOMPtr<nsIURI> uri;
 153     nsresult rv;
 154     char buf[512];
 155     while (fgets(buf, sizeof(buf), fp)) {
 156         // remove trailing newline
 157         buf[strlen(buf) - 1] = 0;
 158         rv = NS_NewURI(getter_AddRefs(uri), buf, nsnull, gIOService);
 159         if (NS_FAILED(rv))
 160             printf("*** ignoring malformed uri: %s\n", buf);
 161         else {
 162             //nsXPIDLCString spec;
 163             //uri->GetSpec(getter_Copies(spec));
 164             //printf("read url: %s\n", spec.get());
 165             urls->AppendElement(uri);
 166         }
 167     }
 168
 169     fclose(fp);
 170     return NS_OK;
 171 }
 172
 173 //-----------------------------------------------------------------------------
 174
 175 static void
 176 print_usage()
 177 {
 178     printf("usage: TestPerf [-sync|-async] <file-of-urls>\n");
 179 }
 180
 181 } // namespace
 182
 183 using namespace TestPerf;
 184
 185 int
 186 main(int argc, char **argv)
 187 {
 188     if (test_common_init(&argc, &argv) != 0)
 189         return -1;
 190
 191     nsresult rv;
 192     PRBool sync;
 193
 194     if (argc < 3) {
 195         print_usage();
 196         return -1;
 197     }
 198
 199     if (PL_strcasecmp(argv[1], "-sync") == 0)
 200         sync = PR_TRUE;
 201     else if (PL_strcasecmp(argv[1], "-async") == 0)
 202         sync = PR_FALSE;
 203     else {
 204         print_usage();
 205         return -1;
 206     }
 207
 208     nsCOMPtr<nsIServiceManager> servMan;
 209     NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull);
 210     nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
 211     NS_ASSERTION(registrar, "Null nsIComponentRegistrar");
 212     registrar->AutoRegister(nsnull);
 213
 214     // cache the io service
 215     {
 216         nsCOMPtr<nsIIOService> ioserv( do_GetIOService() );
 217         NS_ADDREF(gIOService = ioserv);
 218     }
 219
 220     nsCOMPtr<nsISupportsArray> urls;
 221     rv = NS_NewISupportsArray(getter_AddRefs(urls));
 222     if (NS_FAILED(rv)) return -1;
 223
 224     rv = read_file(argv[2], urls);
 225     if (NS_FAILED(rv)) {
 226         printf("failed reading file-of-urls\n");
 227         return -1;
 228     }
 229
 230     PRUint32 urlCount;
 231     urls->Count(&urlCount);
 232
 233     PRIntervalTime start = PR_IntervalNow();
 234
 235     if (sync)
 236         rv = load_sync(urls);
 237     else
 238         rv = load_async(urls);
 239
 240     if (NS_FAILED(rv)) {
 241         printf("load failed\n");
 242         return -1;
 243     }
 244
 245     PRIntervalTime end = PR_IntervalNow();
 246     fprintf(stderr, "read: %u urls; total time: %u milliseconds\n",
 247             urlCount,
 248             PR_IntervalToMilliseconds(end - start));
 249
 250     NS_RELEASE(gIOService);
 251     return 0;
 252 }