अतुल्यकालिक हिट

जैसा कि किसी ने शायद पहले ही अनुमान लगाया था, इस लेख में हम सॉकेट्स, और फ्रेमवर्क के बारे में बात करेंगे जो उनके साथ काम करना आसान बनाते हैं। हाल ही में, मैंने एक नई परियोजना, एक ऑनलाइन गेम पर काम शुरू किया। ऐसी परियोजनाओं के लिए, सर्वर से प्रतिक्रिया समय काफी महत्वपूर्ण है, जब तक कि यह निश्चित रूप से एक बारी-आधारित रणनीति नहीं है, हालांकि इस मामले में भी, शायद। तो यह गंभीर संसाधन बाधाओं के साथ कैसे प्राप्त किया जा सकता है?

• उदाहरण के लिए, अनावश्यक काम से सर्वर को सुविधाजनक बनाने के लिए, इसके बजाय जावास्क्रिप्ट टेम्पलेट इंजन का उपयोग करते हुए, पृष्ठ को ही रेंडर करना।
• एक अच्छे फ्रंट-एंड का उपयोग करें, उदाहरण के लिए, nginx, पहला बिंदु देखते हुए, हमारे पास कोई गतिशीलता नहीं है, और यह हमारे लिए काफी उपयुक्त है।
• उदाहरण के लिए बवंडर का उपयोग करते हुए, फ्रंटेंड पर लोड को संतुलित करना।

मुख्य सवाल यह है कि जब उपयोगकर्ता कोई कार्रवाई करता है तो क्या होगा? सामान्य अजाक्स अनुरोध काम नहीं करेगा, यह स्पष्ट है कि क्यों। इसलिए, सॉकेट हमारी सहायता के लिए आते हैं।

Predystoiya

खेल फ्लैश पर नहीं बनाया गया है, और जेएस को पता नहीं है कि सॉकेट्स के साथ कैसे काम किया जाए, इसलिए आप एक फ्लैश सब्सट्रेट का उपयोग कर सकते हैं जो इस मुद्दे से निपटेंगे। यहाँ एक छोटी सी जस्केट लाइब्रेरी हमारी मदद करेगी।
सर्वर के लिए, सबसे पहले, ध्यान मुड़ गया, और यहां तक ​​कि कुछ लिखना भी शुरू कर दिया, क्योंकि मैंने अपने लिए दिलचस्प साधनों का एक पूरा पहाड़ खोजा, जिनमें से जियोवेंट और बवंडर को सबसे अधिक पसंद किया। उनमें से प्रत्येक के बारे में जानकारी खोजने के बाद, मुझे एक दिलचस्प लेख मिला, और बाद में यह एक । हालांकि, मुझे जो चाहिए, उससे थोड़ा अलग कार्य माना जाता है, इसलिए मैंने अपना परीक्षण करने का फैसला किया।

स्क्रिप्ट

हम मुड़ परीक्षणों के लिए एक सरल ग्राहक लिख रहे हैं।

from twisted.internet.protocol import ClientFactory from twisted.protocols.basic import LineReceiver from twisted.internet import epollreactor epollreactor.install() from twisted.internet import reactor import sys,time clients=30000 host='127.0.0.1' port=8001 file = open( 'log.dat', 'w') class glob(): connections=0 crefuse=0 clost=0 def enchant(self): self.connections+=1 def refuse(self): self.crefuse+=1 def lost(self): self.clost+=1 a=glob() class EchoClient(LineReceiver): measure=True def connectionMade(self): self.sendLine("Hello, world!") self.t1 = time.time() def lineReceived(self, line): if self.measure: self.t2 = time.time() - self.t1 file.write('%s %s %s %s %s\n' % (a.connections+1,self.t2,a.crefuse,a.clost,line)) self.measure=False if a.connections+1 < clients: a.enchant() reactor.connectTCP(host, port, EchoClientFactory()) else: self.transport.loseConnection() class EchoClientFactory(ClientFactory): protocol = EchoClient def clientConnectionFailed(self, connector, reason): a.refuse() def clientConnectionLost(self, connector, reason): a.lost() def main(): f = EchoClientFactory() reactor.connectTCP(host, port, f) reactor.run() file.close() if __name__ == '__main__': main() 

और हर ढांचे पर एक सर्वर।

gevent

 clients=[] host='' port = 8001 def echo(socket, address): clients.append(socket) while True: line = socket.recv(1024) for client in clients: try: client.send(str(len(clients))+'\r\n') except: clients.remove(client) if __name__ == '__main__': from gevent.server import StreamServer StreamServer((host, port), echo).serve_forever() 

बवंडर

 import errno import functools import socket from tornado import ioloop, iostream host='' port = 8001 clients=[] class Connection(object): def __init__(self, connection): clients.append(self) self.stream = iostream.IOStream(connection) self.read() def read(self): self.stream.read_until('\r\n', self.eol_callback) def eol_callback(self, data): for c in clients: try: c.stream.write(str(len(clients))+'\r\n') except: clients.remove(c) self.read() def connection_ready(sock, fd, events): while True: try: connection, address = sock.accept() except socket.error, e: if e[0] not in (errno.EWOULDBLOCK, errno.EAGAIN): raise return connection.setblocking(0) Connection(connection) if __name__ == '__main__': sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.setblocking(0) sock.bind((host, port)) sock.listen(30000) io_loop = ioloop.IOLoop.instance() callback = functools.partial(connection_ready, sock) io_loop.add_handler(sock.fileno(), callback, io_loop.READ) try: io_loop.start() except KeyboardInterrupt: io_loop.stop() print "exited cleanly" 

मुड़

 from twisted.protocols import basic class MyChat(basic.LineReceiver): def connectionMade(self): self.factory.clients.append(self) def connectionLost(self, reason): self.factory.clients.remove(self) def dataReceived(self, line): for c in self.factory.clients: c.message(str(len(factory.clients))+'\r\n') def message(self, message): self.transport.write(message) from twisted.internet import epollreactor epollreactor.install() from twisted.internet import reactor, protocol from twisted.application import service, internet factory = protocol.ServerFactory() factory.protocol = MyChat factory.clients = [] reactor.listenTCP(8001,factory) reactor.run() 

थोड़ा स्पष्टीकरण

वास्तव में, हमने एक चैट सर्वर बनाया है। जैसे ही सर्वर को क्लाइंट से एक लाइन मिलती है, यह इस लाइन को सभी कनेक्टेड क्लाइंट्स को भेजता है (अधिक सटीक रूप से, इसके बजाय हम कनेक्टेड क्लाइंट की संख्या भेजते हैं)। इस प्रकार, भार अंकगणितीय रूप से बढ़ जाता है। क्लाइंट, बदले में, सर्वर को संदेश भेजने और उससे प्रतिक्रिया प्राप्त करने के बीच बीता समय को मापता है। चूंकि हमारा वर्तमान ग्राहक कनेक्ट करने के लिए अंतिम था, इसलिए इस समय तक सभी ग्राहकों को पहले ही प्रतिक्रिया मिल जाएगी।

माप के दौरान, मैंने कनेक्टेड उपयोगकर्ताओं की संख्या के लिए प्रतिक्रिया समय लिया। क्लाइंट और सर्वर को एक लोकलहोस्ट पर लॉन्च किया गया था। मशीन का उपयोग डेस्कटॉप के रूप में किया जाता है, इसलिए परिणाम थोड़ा विकृत हो सकते हैं, लेकिन सार स्पष्ट है। यह 30,000 कनेक्शन तक निर्भरता को मापने की योजना बनाई गई थी, लेकिन दुर्भाग्य से तीनों रूपरेखाओं के लिए यह बहुत लंबा हो गया।

प्रतिक्रिया अक्ष पर, समय, निश्चित रूप से, सेकंड में है।
बवंडर ग्राफ दो लाइनों को दर्शाता है। ये दो परीक्षण नहीं हैं, लेकिन एक, सिर्फ परिणाम इस तरह के हैं:
11476 2.45670819283
11477 0.405035018921
11478 2.42619085312
11479 0.392680883408
11480 2.5216550827
11481 0.401995897293

जहां पहला नंबर कनेक्शनों की संख्या है, और दूसरा प्रतिक्रिया समय है। मुझे नहीं पता कि यह किससे जुड़ा है।

निष्कर्ष

मैं कार्य के हिस्से के रूप में सभी पेशेवरों और विपक्षों की एक सूची देता हूं

Gevent

• + उच्च गति।
• + संक्षिप्त कोड।
• - बहुत सुविधाजनक नहीं है।

मुड़

• + स्पष्ट कोड।
• + कई अतिरिक्त सुविधाएँ।
• + व्यापक प्रलेखन।
• - घर साइट Braked।
• - धीमा।

बवंडर

• + वह सबसे तेज़ था।
• - कोई दस्तावेज नहीं
• - बहुत सुविधाजनक नहीं है।
• - अस्थिर प्रतिक्रिया समय।

खैर, उपरोक्त सभी से, हर कोई अपने लिए निष्कर्ष निकाल सकता है। मैं अपने और अपने कामों के लिए जियोवेंट चुनूंगा।

युपीडी। जियोवेंट स्क्रिप्ट के साथ थोड़ा गलत है। उस पर भार कम था। मैंने इसे मापा, परिणाम थोड़ा खराब निकला, लेकिन सबसे अच्छा रहा। यहाँ नमूना परिणाम हैं:
10336 1.01536607742 0 0 10338
10337 0.955881118774 0 0 10339
10338 0.947958946228 0 0 10340
10339 1.02578997612 0 0 10341