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

Last change on this file since 6894 was 6894, checked in by jonb, 12 years ago

mod_tile: Update to a new meta tile scheme which stores all sub-tiles in a single .meta file. The PNG files are extracted from this on the fly by mod_tile. This is more efficient in disk space and inode usage

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