← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/haxe/oneiric

« back to all changes in this revision

Viewing changes to haxe/tests/benchs/MTNetwork.hx

  • Committer: Bazaar Package Importer
  • Author(s): Jens Peter Secher
  • Date: 2008-06-15 11:04:09 UTC
  • mfrom: (2.1.6 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080615110409-7pyykgwmk5v0cues
Tags: 1:1.19-3
http://bugs.debian.org/484390
* Remove bashism in script.
  (Closes: #484390)
* Upgrade to Policy 3.8.0 by including a README.source explaining how to
  use dpatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
haxe/tests/benchs/MTNetwork.hx
 
1
class Const {
 
2
 
 
3
        public static var HOST = new neko.net.Host("localhost");
 
4
        public static var PORT = 1234;
 
5
        public static var LOOPS = 3000;
 
6
        public static var CLIENTS = 200;
 
7
        public static var SOCKETS = 5;
 
8
        public static var SERVERS = 16;
 
9
        public static var USE_POLL = true;
 
10
 
 
11
}
 
12
 
 
13
class Task  {
 
14
 
 
15
        var t : neko.vm.Thread;
 
16
        public var done : Bool;
 
17
 
 
18
        public function new() {
 
19
                t = neko.vm.Thread.create(run);
 
20
        }
 
21
 
 
22
        function run() {
 
23
                try {
 
24
                        loop();
 
25
                } catch( e : Dynamic ) {
 
26
                        neko.Lib.print(e);
 
27
                        neko.Lib.print("\n");
 
28
                        neko.Lib.print(haxe.Stack.toString(haxe.Stack.exceptionStack()));
 
29
                        neko.Lib.print("\n");
 
30
                }
 
31
                done = true;
 
32
        }
 
33
 
 
34
        function loop() {
 
35
                // TODO
 
36
        }
 
37
 
 
38
}
 
39
 
 
40
class Client extends Task {
 
41
 
 
42
        public var time : Float;
 
43
 
 
44
        public function new() {
 
45
                time = 0;
 
46
                super();
 
47
        }
 
48
 
 
49
        function loop() {
 
50
                var sockets = new Array();
 
51
                for( i in 0...Const.SOCKETS ) {
 
52
                        var s = new neko.net.Socket();
 
53
                        while( true ) {
 
54
                                var ok = true;
 
55
                                try {
 
56
                                        s.connect(Const.HOST,Const.PORT);
 
57
                                } catch( e : Dynamic ) {
 
58
                                        ok = false;
 
59
                                        neko.Lib.print("C");
 
60
                                        neko.Sys.sleep(0.1);
 
61
                                }
 
62
                                if( ok )
 
63
                                        break;
 
64
                        }
 
65
                        sockets.push(s);
 
66
                }
 
67
                var event = Math.round(Const.LOOPS / Const.SOCKETS);
 
68
                var t = neko.Sys.time();
 
69
                for( i in 0...Const.LOOPS ) {
 
70
                        var c = i % 256;
 
71
                        var k = Std.random(sockets.length);
 
72
                        var s = sockets[k];
 
73
                        s.output.writeChar(c);
 
74
                        if( s.input.readChar() != c ) throw "???";
 
75
                        if( k > 0 && k == sockets.length - 1 && Std.random(event) == 0 ) {
 
76
                                neko.Lib.print("x");
 
77
                                s.close();
 
78
                                sockets.remove(s);
 
79
                        }
 
80
                }
 
81
                time = neko.Sys.time() - t;
 
82
                for( s in sockets ) {
 
83
                        neko.Lib.print("x");
 
84
                        s.close();
 
85
                }
 
86
        }
 
87
 
 
88
}
 
89
 
 
90
class ServerSelect extends Task {
 
91
 
 
92
        var sockets : Array<neko.net.Socket>;
 
93
 
 
94
        public function new(size) {
 
95
                sockets = new Array();
 
96
                super();
 
97
        }
 
98
 
 
99
        public function addClient(sock) {
 
100
                t.sendMessage(sock);
 
101
        }
 
102
 
 
103
        function loop() {
 
104
                var s : neko.net.Socket = neko.vm.Thread.readMessage(true);
 
105
                sockets.push(s);
 
106
                while( true ) {
 
107
                        for( s in neko.net.Socket.select(sockets,null,null,0.1).read ) {
 
108
                                try {
 
109
                                        s.output.writeChar(s.input.readChar());
 
110
                                } catch( e : Dynamic ) {
 
111
                                        neko.Lib.print("-");
 
112
                                        sockets.remove(s);
 
113
                                        s.close();
 
114
                                }
 
115
                        }
 
116
                        while( true ) {
 
117
                                var s : neko.net.Socket = neko.vm.Thread.readMessage(false);
 
118
                                if( s == null ) {
 
119
                                        if( sockets.length != 0 )
 
120
                                                break;
 
121
                                        done = true;
 
122
                                        s = neko.vm.Thread.readMessage(true);
 
123
                                        done = false;
 
124
                                }
 
125
                                sockets.push(s);
 
126
                                neko.Lib.print("+");
 
127
                        }
 
128
                }
 
129
        }
 
130
 
 
131
}
 
132
 
 
133
 
 
134
class ServerEvents extends Task {
 
135
 
 
136
        var sockets : Array<neko.net.Socket>;
 
137
        var poll : neko.net.Poll;
 
138
 
 
139
        public function new(size) {
 
140
                sockets = new Array();
 
141
                poll = new neko.net.Poll(size);
 
142
                super();
 
143
        }
 
144
 
 
145
        public function addClient(sock) {
 
146
                t.sendMessage(sock);
 
147
        }
 
148
 
 
149
        function loop() {
 
150
                var toremove = new Array();
 
151
                while( true ) {
 
152
                        poll.events(0.1);
 
153
                        var i = 0;
 
154
                        var idx = poll.readIndexes;
 
155
                        while( true ) {
 
156
                                var s = sockets[idx[i]];
 
157
                                if( s == null )
 
158
                                        break;
 
159
                                i++;
 
160
                                try {
 
161
                                        s.output.writeChar(s.input.readChar());
 
162
                                } catch( e : Dynamic ) {
 
163
                                        neko.Lib.print("-");
 
164
                                        toremove.push(s);
 
165
                                }
 
166
                        }
 
167
                        if( toremove.length > 0 ) {
 
168
                                for( s in toremove ) {
 
169
                                        sockets.remove(s);
 
170
                                        s.close();
 
171
                                }
 
172
                                poll.prepare(sockets,[]);
 
173
                                toremove = new Array();
 
174
                        }
 
175
                        var mod = false;
 
176
                        while( true ) {
 
177
                                var s : neko.net.Socket = neko.vm.Thread.readMessage(false);
 
178
                                if( s == null ) {
 
179
                                        if( sockets.length != 0 )
 
180
                                                break;
 
181
                                        done = true;
 
182
                                        s = neko.vm.Thread.readMessage(true);
 
183
                                        done = false;
 
184
                                }
 
185
                                sockets.push(s);
 
186
                                mod = true;
 
187
                                neko.Lib.print("+");
 
188
                        }
 
189
                        if( mod )
 
190
                                poll.prepare(sockets,[]);
 
191
                }
 
192
        }
 
193
 
 
194
}
 
195
 
 
196
 
 
197
class MTNetwork {
 
198
 
 
199
        static var cputime : Void -> Float = neko.Lib.load("std","sys_cpu_time",0);
 
200
 
 
201
        static function main() {
 
202
 
 
203
                var size = Math.round(Const.CLIENTS * Const.SOCKETS / Const.SERVERS);
 
204
                trace("Starting on "+Const.HOST.toString()+":"+Const.PORT);
 
205
                trace("Socket per server "+size);
 
206
 
 
207
                var cpu = cputime();
 
208
                var time = neko.Sys.time();
 
209
 
 
210
                var sock = new neko.net.Socket();
 
211
                sock.bind(Const.HOST,Const.PORT);
 
212
                sock.listen(Const.CLIENTS * Const.SOCKETS);
 
213
 
 
214
                var servers = new Array<{ done : Bool, addClient : neko.net.Socket -> Void }>();
 
215
                for( i in 0...Const.SERVERS )
 
216
                        if( Const.USE_POLL )
 
217
                                servers.push(new ServerEvents(size));
 
218
                        else
 
219
                                servers.push(new ServerSelect(size));
 
220
 
 
221
                var clients = new Array();
 
222
                for( i in 0...Const.CLIENTS )
 
223
                        clients.push(new Client());
 
224
 
 
225
                for( cid in 0...Const.CLIENTS * Const.SOCKETS ) {
 
226
                        var s = sock.accept();
 
227
                        s.setBlocking(false);
 
228
                        servers[cid%servers.length].addClient(s);
 
229
                }
 
230
 
 
231
                var done = false;
 
232
                while( !done ) {
 
233
                        done = true;
 
234
                        for( c in clients )
 
235
                                if( !c.done ) {
 
236
                                        done = false;
 
237
                                        break;
 
238
                                }
 
239
                        if( !done ) {
 
240
                                neko.Sys.sleep(0.5);
 
241
                                continue;
 
242
                        }
 
243
                        for( s in servers )
 
244
                                if( !s.done ) {
 
245
                                        done = false;
 
246
                                        break;
 
247
                                }
 
248
                        neko.Sys.sleep(0.5);
 
249
                }
 
250
 
 
251
                var cpu2 = cputime();
 
252
                var time2 = neko.Sys.time();
 
253
 
 
254
                var st = 0.;
 
255
                var min = 1000.;
 
256
                var max = 0.;
 
257
                for( c in clients ) {
 
258
                        st += c.time;
 
259
                        if( c.time < min ) min = c.time;
 
260
                        if( c.time > max ) max = c.time;
 
261
                }
 
262
                neko.Lib.print("\n");
 
263
                trace("AVG = "+(st / (Const.CLIENTS * Const.LOOPS)));
 
264
                trace("MIN = "+(min / Const.LOOPS));
 
265
                trace("MAX = "+(max / Const.LOOPS));
 
266
                trace("CPU = "+((cpu2 - cpu) / Const.LOOPS));
 
267
                trace("TOTAL TIME = "+((time2 - time) / Const.LOOPS));
 
268
                trace("DONE");
 
269
        }
 
270
 
 
271
}