source: subversion/applications/utils/mod_tile/speedtest.cpp @ 28454

Last change on this file since 28454 was 27631, checked in by apmon, 8 years ago

[renderd] Make speedtest configurable for renderd socket and map name

File size: 7.4 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <sys/types.h>
5#include <sys/socket.h>
6#include <sys/stat.h>
7#include <sys/time.h>
8#include <sys/un.h>
9#include <poll.h>
10#include <errno.h>
11#include <math.h>
12#include <limits.h>
13#include <string.h>
14#include <getopt.h>
15
16#include "gen_tile.h"
17#include "protocol.h"
18#include "render_config.h"
19#include "dir_utils.h"
20
21#define DEG_TO_RAD (M_PI/180)
22#define RAD_TO_DEG (180/M_PI)
23
24#ifndef METATILE
25#warning("Speed test not implemented for non-metatile mode. Feel free to submit fix")
26int main(int argc, char **argv)
27{
28    fprintf(stderr, "Speed test not implemented for non-metatile mode. Feel free to submit fix!\n");
29    return -1;
30}
31#else
32
33static const int minZoom = 0;
34static const int maxZoom = 18;
35
36#if 1
37static double boundx0=-0.5;
38static double boundy0=51.25;
39static double boundx1=0.5;
40static double boundy1=51.75;
41#endif
42#if 0
43//    bbox = (-6.0, 50.0,3.0,58.0)
44static double boundx0=-6.0;
45static double boundy0=50.0;
46static double boundx1=3.0;
47static double boundy1=58.0;
48#endif
49#if 0
50// UK: 49.7,-7.6, 58.8, 3.2
51static double boundx0=-7.6;
52static double boundy0=49.7;
53static double boundx1=3.2;
54static double boundy1=58.8;
55#endif
56
57
58static double minmax(double a, double b, double c)
59{
60#define MIN(x,y) ((x)<(y)?(x):(y))
61#define MAX(x,y) ((x)>(y)?(x):(y))
62    a = MAX(a,b);
63    a = MIN(a,c);
64    return a;
65}
66
67class GoogleProjection
68{
69    double *Ac, *Bc, *Cc, *zc;
70
71    public:
72        GoogleProjection(int levels=18) {
73            Ac = new double[levels];
74            Bc = new double[levels];
75            Cc = new double[levels];
76            zc = new double[levels];
77            int d, c = 256;
78            for (d=0; d<levels; d++) {
79                int e = c/2;
80                Bc[d] = c/360.0;
81                Cc[d] = c/(2 * M_PI);
82                zc[d] = e;
83                Ac[d] = c;
84                c *=2;
85            }
86        }
87
88        void fromLLtoPixel(double &x, double &y, int zoom) {
89            double d = zc[zoom];
90            double f = minmax(sin(DEG_TO_RAD * y),-0.9999,0.9999);
91            x = round(d + x * Bc[zoom]);
92            y = round(d + 0.5*log((1+f)/(1-f))*-Cc[zoom]);
93        }
94        void fromPixelToLL(double &x, double &y, int zoom) {
95            double e = zc[zoom];
96            double g = (y - e)/-Cc[zoom];
97            x = (x - e)/Bc[zoom];
98            y = RAD_TO_DEG * ( 2 * atan(exp(g)) - 0.5 * M_PI);
99        }
100};
101
102static GoogleProjection gprj(maxZoom+1);
103
104
105void display_rate(struct timeval start, struct timeval end, int num) 
106{
107    int d_s, d_us;
108    float sec;
109
110    d_s  = end.tv_sec  - start.tv_sec;
111    d_us = end.tv_usec - start.tv_usec;
112
113    sec = d_s + d_us / 1000000.0;
114
115    printf("Rendered %d tiles in %.2f seconds (%.2f tiles/s)\n", num, sec, num / sec);
116    fflush(NULL);
117}
118
119
120
121int rx_process(const struct protocol *req)
122{
123    fprintf(stderr, "version(%d), cmd(%d), z(%d), x(%d), y(%d)\n",
124            req->ver, req->cmd, req->z, req->x, req->y);
125    return 0;
126}
127
128int process_loop(int fd, int x, int y, int z, char * map)
129{
130    struct protocol cmd, rsp;
131    //struct pollfd fds[1];
132    int ret = 0;
133
134    bzero(&cmd, sizeof(cmd));
135
136    cmd.ver = 2;
137    cmd.cmd = cmdRender;
138    cmd.z = z;
139    cmd.x = x;
140    cmd.y = y;
141    strcpy(cmd.xmlname, map);
142    //strcpy(cmd.path, "/tmp/foo.png");
143
144        //printf("Sending request\n");
145    ret = send(fd, &cmd, sizeof(cmd), 0);
146    if (ret != sizeof(cmd)) {
147        perror("send error");
148    }
149        //printf("Waiting for response\n");
150    bzero(&rsp, sizeof(rsp));
151    ret = recv(fd, &rsp, sizeof(rsp), 0);
152    if (ret != sizeof(rsp)) {
153        perror("recv error");
154        return 0;
155    }
156        //printf("Got response\n");
157
158    if (!ret)
159        perror("Socket send error");
160    return ret;
161}
162
163
164int main(int argc, char **argv)
165{
166    const char *spath = RENDER_SOCKET;
167    int fd;
168    struct sockaddr_un addr;
169    int ret=0;
170    int z;
171    int c;
172    char name[PATH_MAX];
173    struct timeval start, end;
174    struct timeval start_all, end_all;
175    int num, num_all = 0;
176    char * mapname = "default";
177    int verbose = 0;
178
179    while (1) {
180        int option_index = 0;
181        static struct option long_options[] = {
182            {"socket", 1, 0, 's'},
183            {"map", 1, 0, 'm'},
184            {"verbose", 0, 0, 'v'},
185            {"help", 0, 0, 'h'},
186            {0, 0, 0, 0}
187        };
188
189        c = getopt_long(argc, argv, "hvs:m:", long_options, &option_index);
190        if (c == -1)
191            break;
192
193        switch (c) {
194            case 's':   /* -s, --socket */
195                spath = strdup(optarg);
196                break;
197            case 'm':   /* -m, --map */
198                mapname=strdup(optarg);
199                break;
200            case 'v':   /* -v, --verbose */
201                verbose=1;
202                break;
203            case 'h':   /* -h, --help */
204                fprintf(stderr, "Usage: speedtest [OPTION] ...\n");
205                fprintf(stderr, "  -m, --map=MAP        render tiles in this map (defaults to '" XMLCONFIG_DEFAULT "')\n");
206                fprintf(stderr, "  -s, --socket=SOCKET  unix domain socket name for contacting renderd\n");
207                return -1;
208            default:
209                fprintf(stderr, "unhandled char '%c'\n", c);
210                break;
211        }
212    }
213
214
215 
216   
217    fprintf(stderr, "Rendering client\n");
218
219    fd = socket(PF_UNIX, SOCK_STREAM, 0);
220    if (fd < 0) {
221        fprintf(stderr, "failed to create unix socket\n");
222        exit(2);
223    }
224
225    bzero(&addr, sizeof(addr));
226    addr.sun_family = AF_UNIX;
227    strncpy(addr.sun_path, spath, sizeof(addr.sun_path));
228
229    if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
230        fprintf(stderr, "socket connect failed for: %s\n", spath);
231        close(fd);
232        exit(3);
233    }
234
235    // Render something to counter act the startup costs
236    // of obtaining the Postgis table extents
237
238    printf("Initial startup costs\n");
239    gettimeofday(&start, NULL);
240    process_loop(fd, 0,0,0,mapname);
241    gettimeofday(&end, NULL);
242    display_rate(start, end, 1);
243
244    gettimeofday(&start_all, NULL);
245
246    for (z=minZoom; z<=maxZoom; z++) {
247        double px0 = boundx0;
248        double py0 = boundy1;
249        double px1 = boundx1;
250        double py1 = boundy0;
251        gprj.fromLLtoPixel(px0, py0, z);
252        gprj.fromLLtoPixel(px1, py1, z);
253
254        int x, xmin, xmax;
255        xmin = (int)(px0/256.0);
256        xmax = (int)(px1/256.0);
257
258        int y, ymin, ymax;
259        ymin = (int)(py0/256.0);
260        ymax = (int)(py1/256.0);
261
262        num = (xmax - xmin + 1) * (ymax - ymin + 1);
263//        if (!num) {
264//            printf("No tiles at zoom(%d)\n", z);
265//            continue;
266//        }
267
268        printf("\nZoom(%d) Now rendering %d tiles\n", z, num);
269        num_all += num;
270        gettimeofday(&start, NULL);
271
272        for (x=xmin; x<=xmax; x++) {
273            for (y=ymin; y<=ymax; y++) {
274                struct stat s;
275                xyz_to_meta(name, sizeof(name), HASH_PATH, XMLCONFIG_DEFAULT, x, y, z);
276                if (stat(name, &s) < 0) {
277                // File doesn't exist
278                    ret = process_loop(fd, x, y, z, mapname);
279                }
280                //printf(".");
281                fflush(NULL);
282            }
283        }
284        //printf("\n");
285        gettimeofday(&end, NULL);
286        display_rate(start, end, num);
287    }
288    gettimeofday(&end_all, NULL);
289    printf("\nTotal for all tiles rendered\n");
290    display_rate(start_all, end_all, num_all);
291
292    close(fd);
293    return ret;
294}
295#endif
Note: See TracBrowser for help on using the repository browser.