JSON Toolkit

পাইথনে বড় JSON দ্রুত পড়ার বাস্তব পরীক্ষা: স্ট্যান্ডার্ড লাইব্রেরি, orjson ও msgspec

সংক্ষেপে: NDJSON থেকে Stars গণনাকারী একই স্ক্রিপ্ট স্ট্যান্ডার্ড json লাইব্রেরিতে ৭৫৪ মিলিসেকেন্ড নেয়, কিন্তু msgspec-এর ডিক্লারেটিভ ডিকোডিংয়ে মাত্র ১৪৬ মিলিসেকেন্ড, আর মাল্টিকোর প্যারালালিজম আরও এক মাত্রা বাড়িয়ে দেয়। এই নিবন্ধে ৬১.৪ এমবি ও ৩ লাখ লাইনের নমুনায় stdlib, orjson ও msgspec ধাপে ধাপে পরীক্ষা করা হয়েছে, এবং ব্যাখ্যা করা হয়েছে প্রতিটি গতিবৃদ্ধি কোথা থেকে আসে আর কখন তার সীমা।

উন্নত~6 মিনিট পড়াপ্রকাশ 2026-11-15আপডেট 2026-11-15
পাইথনে বড় JSON পার্সিং দ্রুত করার পথের তুলনা: স্ট্যান্ডার্ড লাইব্রেরি, orjson, msgspec ও মাল্টিকোর প্যারালালিজম

পাইথনের পার্সিংকে ধীর করে কখনও JSON টেক্সট নিজে নয়, বরং প্রতিটি ফিল্ডকে পাইথন অবজেক্টে রূপ দেওয়ার খরচ। ডিফল্ট পার্সার বদলান, কম অবজেক্ট তৈরি করুন, সব কোর ব্যবহার করুন — একই গণনার কাজ 0.08 GB/s থেকে বেড়ে কয়েক দশক GB/s-এ পৌঁছাতে পারে।

একটি পর্যবেক্ষণ: একই কোড, এক মাত্রার পার্থক্য

কাজটি খুব চেনা: GitHub Events ঘরানার NDJSON লগে type সমান WatchEvent এমন রেকর্ডগুলোর মধ্যে কোন রিপোজিটরি সবচেয়ে বেশি স্টার পায় তা গণনা করা। আমার মেশিনে (Ubuntu 22.04, Python 3.12, orjson 3.13, msgspec 0.22) আমি ৬১.৪ এমবি ও ৩ লাখ লাইনের একটি নমুনা ফাইল তৈরি করে চারটি ইমপ্লিমেন্টেশন তিনবার করে চালিয়ে সেরা ফল রেখেছি:

ইমপ্লিমেন্টেশন সেরা সময় হিসাব করা থ্রুপুট তুলনামূলক
json.loads লাইন ধরে ৭৫৪ মি.সে. 0.08 GB/s ১× (ভিত্তি)
orjson.loads লাইন ধরে ২৪৮ মি.সে. 0.24 GB/s 3.0×
msgspec dict-এ ডিকোড ২০১ মি.সে. 0.30 GB/s 3.8×
msgspec ডিক্লারেটিভ Struct ১৪৬ মি.সে. 0.41 GB/s 5.2×

চারটি ইমপ্লিমেন্টেশনই হুবহু একই স্টার গণনা দিয়েছে (৬০,১০৮টি রেকর্ড), অর্থাৎ পুরো পার্থক্য পার্সিং নিজেই থেকে এসেছে। তৃতীয় পক্ষের ডেটাও একই মাত্রার সমর্থন দেয়: World Programming-এর ২০২৬-১১-১৪ তারিখে প্রকাশিত পরীক্ষায় ৭.৬ জিবি ও ২২ লাখ GitHub Archive ইভেন্টের ওপর একই স্ট্যাটিসটিক স্ট্যান্ডার্ড লাইব্রেরিতে 0.28 GB/s (প্রায় ২৭ সেকেন্ড) গতিতে চলেছিল, msgspec-এ প্রায় ৮ গুণ দ্রুত, আর SIMD-ভিত্তিক fastsimdjson ১৯২ থ্রেডে ৫৫ মিলিসেকেন্ডে পুরো ডেটাসেট শেষ করেছে (138 GB/s), একক ফাইলে সর্বোচ্চ 277 GB/s-এ পৌঁছেছে। মনে রাখুন, তাদের মেশিন ১৯২ কোরের AWS c8a.metal-48xl, তাই সংখ্যাগুলো সরাসরি ল্যাপটপে প্রযোজ্য নয় — তবে সিঁড়ির গঠন একই।

স্ট্যান্ডার্ড লাইব্রেরি কোথায় সময় হারায়

লাইন ধরে json.loads চালানোর পদ্ধতি প্রতিটি ধাপে "পূর্ণ অনুবাদ" করে: পার্সার {"id": 1, "type": "WatchEvent", ...} ঘুরে দেখে, ওই এক রেকর্ডের জন্য নতুন একটি dict, অন্তত সাতটি str অবজেক্ট ও কয়েকটি int তৈরি করে, তারপর রেফারেন্সগুলো আপনার কোডে দেয়। তিন লাখ লাইন মানে লাখ লাখ ছোট অবজেক্ট অ্যালোকেশন, যার বেশিরভাগে আপনি কখনও হাত দেন না — গণনার কাজ কেবল দুটি ফিল্ড পড়ে, type ও repo.name।

দ্বিতীয় সীমা হলো GIL। CPython-এ একই মুহূর্তে কেবল একটি থ্রেড পাইথন বাইটকোড চালায়, আর পার্সারের C কোড যদিও GIL ছেড়ে দেয়, লুপের ভেতরে লেখা আপনার ফিল্টার ও যোগের লজিক সিরিয়ালই থাকে। তাই ডিফল্ট ইন্টারপ্রেটারে "আটটা থ্রেড খোলা" কিছুই সমাধান করে না; ভাবনার দিক বদলাতে হয়।

প্রথম স্তরের গতিবৃদ্ধি: পার্সার বদলান

সবচেয়ে বেশি ফল দেয় এমন ধাপ এটিই — পরিবর্তন শুধু import-এ:

import json
import orjson
import msgspec

dec = msgspec.json.Decoder()

# তিন পার্সারের ইন্টারফেস প্রায় এক, শুধু dumps বাদে:
# orjson.dumps(...) str নয়, bytes ফেরত দেয়
for name, load in [("stdlib", json.loads), ("orjson", orjson.loads), ("msgspec", dec.decode)]:
    stars = {}
    with open("events.ndjson", "rb") as f:
        for line in f:
            e = load(line)
            if e["type"] == "WatchEvent":
                stars[e["repo"]["name"]] = stars.get(e["repo"]["name"], 0) + 1

orjson Rust-এ লেখা, পার্সিংয়ের সময় সরাসরি UTF-8 বাইট তৈরি করে এবং প্রচুর SIMD নির্দেশনা ব্যবহার করে; আমার মেশিনে এটি তিন গুণ দ্রুত ছিল। একটি API ফাঁদ মনে রাখা দরকার: orjson.dumps() str নয়, bytes ফেরত দেয়, তাই ফাইলে লেখা বা স্ট্রিং জোড়া দেওয়ার সময় সেটি সামলাতে হবে।

msgspec-এর ডিফল্ট ডিকোডিং orjson-এর একই স্তরে (3.8×), কিন্তু এর আসল অস্ত্র ডিক্লারেটিভ ডিকোডিং — ঘোষিত ফিল্ডগুলোর জন্যই কেবল পাইথন অবজেক্ট তৈরি হয়:

import msgspec

class Event(msgspec.Struct):
    type: str
    repo: msgspec.Raw          # এখনও ডিকোড হয়নি, কাঁচা বাইট রাখা হয়

dec = msgspec.json.Decoder(Event)
stars = {}
with open("events.ndjson", "rb") as f:
    for line in f:
        e = dec.decode(line)
        if e.type == "WatchEvent":
            name = msgspec.json.decode(e.repo)["name"]
            stars[name] = stars.get(name, 0) + 1

repo-কে msgspec.Raw ঘোষণা করার সঙ্গে সঙ্গে WatchEvent নয় এমন ২,৪০,০০০ লাইন repo অবজেক্ট তৈরির ধাপ পুরোপুরি এড়িয়ে শুধু টোকেন স্ক্যান করে — 3.8× থেকে 5.2×-এ লাফটা ঠিক এখান থেকেই আসে। রেকর্ডে ফিল্ড যত বেশি আর ফেলে দেওয়ার হার যত বেশি, এই ধাপের লাভ তত বড়।

দ্বিতীয় স্তর: মাল্টিপ্রসেসে ভাগ, তবে লাভ কমতে থাকে

একটি কোর পূর্ণ ব্যবহৃত হলে ধ্রুপদী উত্তর হলো প্রসেস পুল: ফাইলকে N টি বাইট-রেঞ্জে ভাগ করুন (লাইনের সীমানায় সামঞ্জস্য করে), প্রতিটি টুকরো একটি করে ওয়ার্কার প্রসেসের হাতে দিন, আর শেষে Counter-গুলো একত্র করুন। প্রতিটি প্রসেস কেবল ছোট একটি ফলাফল টেবিল ফেরত দেয়, তাই যোগাযোগের খরচ খুবই কম — এটাই map-reduce-এর আদর্শ রূপ।

World Programming-এর পরীক্ষা এই পথের রূপও দেখিয়েছে: msgspec প্রসেস পুল ৯৬টি প্রসেসে 116 GB/s-এ শীর্ষে পৌঁছেছিল, আর তার বেশি প্রসেস যোগ করলে বরং ধীর হয়ে যায় — শিডিউলিং ও একত্রীকরণের খরচ লাভ খেয়ে ফেলে। বাস্তব সীমাবদ্ধতাও দুটি: টুকরোগুলো নতুন লাইনের অক্ষরের সঙ্গে সামঞ্জস্য রাখতে হবে, নইলে প্রতিটি টুকরোর শেষ লাইন পার্সে ব্যর্থ হয়; আর গণনার কাজ (ছোট ফল ফেরত দেয়) প্রসেস পুলের সেরা ক্ষেত্র — যদি প্রতিটি রেকর্ড বের করে ব্যবহার করতে চান, প্রসেসের মধ্যকার স্থানান্তরই নতুন বাধা হয়ে দাঁড়ায়।

তৃতীয় স্তর: SIMD ও ফ্রি-থ্রেডেড পাইথন

fastsimdjson অন্য পথে যায়: এক কোরে 8 GB/s (msgspec-এর প্রায় 3.5 গুণ), কারণ এটি simdjson-এর কাঠামোগত ইন্ডেক্সের ওপর দাঁড়িয়ে — যত্ন করে আগেই যতিচিহ্ন স্ক্যান করে প্রতিটি টোকেনের অবস্থান ঠিক করে, পূর্ণ অবজেক্ট ট্রি বানায় না; fields=["/type", "/repo/name"]-এর সঙ্গে মিলে এটি কেবল ঘোষিত JSON Pointer পথগুলো পড়ে, আর কলব্যাক পায় কেবল ওই দুটি মান।

এটি মাল্টিথ্রেডেডও: Python 3.14-এর ফ্রি-থ্রেডেড বিল্ডের সঙ্গে (python3.14t, GIL সরানোর পিইপি ৭০৩-এর সরকারি প্রচেষ্টা) যুক্ত করলে ১৯২ থ্রেডে ৭.৬ জিবি ৫৫ মিলিসেকেন্ডে প্রসেস হয়েছে। প্রায় ১ জিবির ছয়টি প্রকাশিত বেঞ্চমার্ক ফাইলের চারটি 100 GB/s ছাড়িয়েছে, আর দ্রুততম টুইটার ডেটাসেট 277 GB/s ছুঁয়েছে। মনে রাখুন, এগুলো বিক্রেতার দাবির বাইরে স্বাধীন পুনঃপরিমাপ, আর নমুনা সবচেয়ে অনুকূল পরিস্থিতি — "প্রতি রেকর্ডে এক-দুটি ফিল্ড পড়া"। গভীরভাবে নেস্ট করা ডকুমেন্ট এত উঁচু সংখ্যায় পৌঁছায় না; একটি ২০ GB/s-এর কাছাকাছিই ছিল।

নির্বাচনের তালিকা ও গ্রহণের ক্রম

পথ প্রক্রিয়া থ্রুপুট (স্থানীয়/রেফারেন্স) যার জন্য সেরা
json (stdlib) পূর্ণ অবজেক্ট তৈরি, এক কোর 0.08 GB/s ছোট ফাইল, নির্ভরতাহীন
orjson Rust + SIMD, পূর্ণ অবজেক্ট তৈরি 0.24 GB/s কয়েক লাইনে বদল
msgspec dict Rust, পূর্ণ অবজেক্ট তৈরি 0.30 GB/s orjson-এর সঙ্গে একটি বাছুন
msgspec Struct কেবল ঘোষিত ফিল্ড ডিকোড 0.41 GB/s বড় অ্যারে, বেশি বর্জন হার
msgspec মাল্টিপ্রসেস টুকরো প্যারালাল রেফারেন্স 116 GB/s একত্রীকরণ, ছোট ফলসেট
fastsimdjson কাঠামো ইন্ডেক্স + থ্রেড রেফারেন্স 138-277 GB/s NDJSON ফিল্ড আহরণ, 3.14t

গ্রহণের যুক্তিসঙ্গত ক্রম: আগে msgspec বা orjson-এ যান (কয়েক মিনিটের কাজে ৩-৫ গুণ বিনামূল্যে); কম মনে হলে হট-পাথ ফিল্ডগুলো Struct করুন; গণনার কাজে প্রসেস পুল যোগ করুন; fastsimdjson কেবল তখনই ভাবুন যখন NDJSON থেকে লাইন ধরে ফিল্ড বের করছেন আর পরিবেশ অনুমতি দেয়। বাধা যদি গতি নয় বরং মেমরি হয় — ফাইল এত বড় যে পুরো পড়া যায় না — দিক বদলে যায়: ijson স্ট্রিমিং বা কমান্ড লাইনের jq --stream-এ যান; দেখুন jq দিয়ে বড় JSON স্ট্রিম প্রসেসিং ও বড় JSON-এর পার্সিং, রেন্ডারিং ও স্ট্রিমিং। NDJSON-এর লাইনভিত্তিক নিয়ম পড়ুন JSONL ফাইল হ্যান্ডবুক-এ।

পরিমাপের শৃঙ্খলা ও তিনটি ফাঁদ

প্রথমত, সময়মাপার পদ্ধতি স্থির রাখুন: এই নিবন্ধে প্রতিটি ইমপ্লিমেন্টেশন তিনবার চালিয়ে সেরা ফল নেওয়া হয়েছে (শিডিউলারের কাঁপুনি বাদ দিতে), আর ফাইল পরিমাপ শুরুর আগেই পুরো তৈরি ছিল। তৃতীয় পক্ষের সংখ্যা উদ্ধৃত করলে মেশিনের স্পেসিফিকেশন লিখুন — ১৯২ কোরের 138 GB/s-এর সঙ্গে নিজের ল্যাপটপের এক কোর কখনও তুলনা করবেন না।

দ্বিতীয়ত, শুদ্ধতা আড়াআড়ি যাচাই করুন: চার ইমপ্লিমেন্টেশনের স্টার গণনাই ৬০,১০৮ ছিল। যে কোনো "গতিবৃদ্ধি" গণনা বদলে দিলে সেটা দ্রুত হওয়া নয়, পার্সিংয়ের অর্থ বদলে যাওয়া (ডুপ্লিকেট কি, বড় পূর্ণসংখ্যার নির্ভুলতা)। ফল আগে মেলান, তারপর গতি।

তৃতীয়ত, তিনটি চেনা ফাঁদ: orjson.dumps() bytes ফেরত দেয়, আর str-এর সঙ্গে মেশালে নীরবে b'...' উপসর্গযুক্ত নোংরা ডেটা তৈরি হয়; প্রসেস পুলের টুকরো লাইনের সীমানায় সামঞ্জস্য রাখতে হবে — f.seek(offset)-এর পরে আগে অসম্পূর্ণ লাইনটি ফেলে দিন; 2^53-এর বেশি বড় পূর্ণসংখ্যা পাইথনের যে কোনো পার্সারেই নিরাপদ, কিন্তু ফল জাভাস্ক্রিপ্ট দিকে গেলে নির্ভুলতার সমস্যা ওইখানেই অপেক্ষা করছে।

সাধারণ প্রশ্ন

orjson না msgspec — কোনটি বাছব?

শুধু দ্রুত loads চাইলে দুটোই ৩ গুণ বা তার বেশি দেয় — রক্ষণাবেক্ষণের সক্রিয়তা ও দলের পরিচিতি দেখে বাছুন। আংশিক ডিকোডিং (msgspec.Struct + Raw), টাইপ যাচাই বা TypedDict/dataclass আউটপুট দরকার হলে msgspec বাছুন; এর ডিক্লারেটিভ ডিকোডিং বড় অ্যারেতে স্বতন্ত্র আরেক স্তরের লাভ জোগায়।

মাল্টিপ্রসেস কি সবসময় এক কোরের চেয়ে দ্রুত?

না। ভাগ, প্রসেস শুরু ও একত্রীকরণের স্থির খরচ আছে, আর কয়েক দশক এমবির ফাইলে তা সাধারণত ক্ষতি। বড় ফল ফেরত দেওয়া কাজ (প্রতিটি রেকর্ড দরকার) স্থানান্তরের খরচে লাভ হারায়। অভিজ্ঞতার নিয়ম: আগে এক কোরে লাইব্রেরি বদলান, আর জিবি মাত্রার বিশুদ্ধ গণনায় অপ্রতুল মনে হলে তবেই প্যারালাল করুন।

আমার orjson বেঞ্চমার্ক ৩ গুণ দেখাচ্ছে না কেন?

তিনটি চেনা কারণ: নমুনা খুব ছোট (পার্সিংয়ের সময় ফাইল পড়া ও লুপের খরচে ডুবে যায়); আসল বাধা নেটওয়ার্ক বা ডিস্ক, পার্সিং নয়; বা ডেটা প্রায় সবই দীর্ঘ স্ট্রিং, তাই অবজেক্ট তৈরির ভাগ কম। বড় নমুনা নিন, কেবল পার্সিং লুপটি time.perf_counter দিয়ে মুড়িয়ে তারপর সিদ্ধান্ত নিন।

ijson ও এই লাইব্রেরিগুলোর সম্পর্ক কী?

ijson একটি স্ট্রিমিং ইটারেটর — থ্রুপুট ত্যাগ করে ধ্রুবক মেমরি পায় এবং র‍্যামের চেয়ে অনেক বড় ফাইলের উপযোগী; orjson/msgspec থ্রুপুট খোঁজে কিন্তু প্রতিটি রেকর্ড অবজেক্ট বানায়। দুটির সংঘর্ষ নেই: জিবি মাত্রার NDJSON লাইন ধরে পড়ে msgspec-এর দ্রুত ডিকোডেই চলে; ijson বা jq --stream দরকার কেবল একক বিশাল JSON ডকুমেন্টে।