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

Last change on this file since 28681 was 28680, checked in by apmon, 7 years ago

[mod_tile] bzero is defined in <strings.h> but was not included

On Linux strings.h must have been included through some other header,
but on solaris it isn't. So it needs to explicitly be included.

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