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