From 7b05dc113cfd04147b594f4ebc44e3fe94b408d2 Mon Sep 17 00:00:00 2001 From: Bivas-Biswas Date: Tue, 19 Aug 2025 18:22:20 +0530 Subject: [PATCH 1/7] =?UTF-8?q?=F0=9F=93=88=20added:=20benchmark=20code=20?= =?UTF-8?q?to=20measure=20end=20to=20end?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- addition_malabr/Dockerfile | 35 ++- addition_malabr/modelserver/server.py | 98 +++---- addition_malabr/modelserver_uds/app/router.py | 2 +- .../read_server_uds_extension/popup.html | 9 + .../read_server_uds_extension/popup.js | 239 ++++++++++++++--- .../reading server extension/popup.html | 5 +- .../reading server extension/popup.js | 240 +++++++++++++++--- 7 files changed, 490 insertions(+), 138 deletions(-) diff --git a/addition_malabr/Dockerfile b/addition_malabr/Dockerfile index 4bea4f02b9cf40..5de0e152f6308e 100644 --- a/addition_malabr/Dockerfile +++ b/addition_malabr/Dockerfile @@ -1,20 +1,22 @@ -# Use Ubuntu as base image -FROM ubuntu:22.04 +# Use official Python slim image +FROM python:3.11-slim -# Prevent interactive prompts during package installation -ENV DEBIAN_FRONTEND=noninteractive +# Disable bytecode generation & buffer output +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 -# Install system dependencies -RUN apt-get update && apt-get install -y \ - python3 \ - python3-pip \ - python3-dev \ +# Set working directory +WORKDIR /app + +# Install system dependencies (optional but helps in many cases) +RUN apt-get update && apt-get install -y --no-install-recommends \ build-essential \ git \ curl \ - sudo && \ - apt-get clean && \ - rm -rf /var/lib/apt/lists/* + && rm -rf /var/lib/apt/lists/* + +# Upgrade pip first +RUN pip install --upgrade pip # Set working directory WORKDIR /app @@ -25,9 +27,16 @@ COPY modelserver/myrequirements.txt . # Install Python packages RUN pip install -r myrequirements.txt +RUN pip install gunicorn # Expose the Flask app port EXPOSE 5000 +# Ensure debug is off +# ENV FLASK_ENV=production +# ENV FLASK_DEBUG=0 + # Run the Python Flask app -CMD ["python3", "server.py"] +# CMD ["python3", "server.py"] +CMD ["gunicorn", "-k", "gthread", "-w", "1", "--threads", "5", "-b", "0.0.0.0:5000", "server:app"] + diff --git a/addition_malabr/modelserver/server.py b/addition_malabr/modelserver/server.py index d1d4f7090a5763..a8ef2bd4a2b827 100644 --- a/addition_malabr/modelserver/server.py +++ b/addition_malabr/modelserver/server.py @@ -1,69 +1,70 @@ from flask import Flask, request, jsonify import time +from threading import Lock import tensorflow as tf import torch from transformers import pipeline +import os app = Flask(__name__) # Global variable for QA pipeline. qa_pipeline = None +qa_pipeline_lock = Lock() @app.route('/load_model_bert', methods=['POST']) def load_model_bert(): - global qa_pipeline - try: - qa_pipeline = pipeline( - "question-answering", - model="csarron/mobilebert-uncased-squad-v2", - tokenizer="csarron/mobilebert-uncased-squad-v2" - ) - app.logger.info("Model loaded successfully.") - return jsonify({"status": "Model loaded successfully."}) - except Exception as e: - app.logger.error("Failed to load model", exc_info=True) - return jsonify({"error": f"Failed to load model: {str(e)}"}), 500 + with qa_pipeline_lock: + global qa_pipeline + try: + qa_pipeline = pipeline( + "question-answering", + model="csarron/mobilebert-uncased-squad-v2", + tokenizer="csarron/mobilebert-uncased-squad-v2" + ) + app.logger.info("Model loaded successfully.") + return jsonify({"status": "Model loaded successfully."}) + except Exception as e: + app.logger.error("Failed to load model", exc_info=True) + return jsonify({"error": f"Failed to load model: {str(e)}"}), 500 @app.route('/infer_single_bert', methods=['POST']) def infer_single_bert(): - global qa_pipeline - if qa_pipeline is None: - return jsonify({"error": "Model not loaded. Please call /load_model_bert first."}), 400 - data = request.get_json() - if not data or 'question' not in data or 'context' not in data: - return jsonify({"error": "Payload must contain 'question' and 'context' fields."}), 400 - try: - prediction = qa_pipeline({ - 'question': data['question'], - 'context': data['context'] - }) - return jsonify(prediction) - except Exception as e: - app.logger.error("Inference error", exc_info=True) - return jsonify({"error": f"Inference error: {str(e)}"}), 500 + with qa_pipeline_lock: + global qa_pipeline + if qa_pipeline is None: + return jsonify({"error": "Model not loaded. Please call /load_model_bert first."}), 400 + data = request.get_json() + if not data or 'question' not in data or 'context' not in data: + return jsonify({"error": "Payload must contain 'question' and 'context' fields."}), 400 + try: + prediction = qa_pipeline(question=data['question'], context=data['context']) + return jsonify(prediction) + except Exception as e: + app.logger.error("Inference error", exc_info=True) + return jsonify({"error": f"Inference error: {str(e)}"}), 500 @app.route('/infer_batch_bert', methods=['POST']) def infer_batch_bert(): - global qa_pipeline - if qa_pipeline is None: - return jsonify({"error": "Model not loaded. Please call /load_model_bert first."}), 400 - data = request.get_json() - if not data or not isinstance(data, list): - return jsonify({"error": "Payload must be an array of objects with 'question' and 'context' fields."}), 400 - results = [] - for idx, item in enumerate(data): - if 'question' not in item or 'context' not in item: - results.append({"error": f"Item at index {idx} is missing 'question' or 'context'."}) - else: - try: - prediction = qa_pipeline({ - 'question': item['question'], - 'context': item['context'] - }) - results.append(prediction) - except Exception as e: - results.append({"error": f"Inference error at index {idx}: {str(e)}"}) - return jsonify(results) + with qa_pipeline_lock: + global qa_pipeline + if qa_pipeline is None: + return jsonify({"error": "Model not loaded. Please call /load_model_bert first."}), 400 + data = request.get_json() + if not data or not isinstance(data, list): + return jsonify({"error": "Payload must be an array of objects with 'question' and 'context' fields."}), 400 + results = [] + for idx, item in enumerate(data): + if 'question' not in item or 'context' not in item: + results.append({"error": f"Item at index {idx} is missing 'question' or 'context'."}) + else: + try: + prediction = qa_pipeline(question=item['question'], context=item['context']) + results.append(prediction) + except Exception as e: + results.append({"error": f"Inference error at index {idx}: {str(e)}"}) + return jsonify(results) + @app.route('/train_model', methods=['POST']) def train_model(): try: @@ -112,4 +113,5 @@ def analyze(): return jsonify({"message": "OP server is working"}) if __name__ == '__main__': - app.run(host='0.0.0.0', port=5000, debug=True) + debug = os.getenv("FLASK_DEBUG", "0") == "1" + app.run(host='0.0.0.0', port=5000, debug=debug) diff --git a/addition_malabr/modelserver_uds/app/router.py b/addition_malabr/modelserver_uds/app/router.py index 72377f55530082..7c72f37e9d19b5 100644 --- a/addition_malabr/modelserver_uds/app/router.py +++ b/addition_malabr/modelserver_uds/app/router.py @@ -20,7 +20,7 @@ def route(conn: socket.socket, payload: Payload): handler = ROUTES.get(label) if handler: - logger.debug(label) + # logger.debug(label) handler(conn, payload) else: logger.error(f"Unknown label: {label}") diff --git a/addition_malabr/read_server_uds_extension/popup.html b/addition_malabr/read_server_uds_extension/popup.html index 85055390b2baeb..ce4dce47a8c2c4 100644 --- a/addition_malabr/read_server_uds_extension/popup.html +++ b/addition_malabr/read_server_uds_extension/popup.html @@ -54,6 +54,15 @@

Single Inference Bert

+
+
+

Benchmark Single Inference Bert

+ +

+

+
+
+ diff --git a/addition_malabr/read_server_uds_extension/popup.js b/addition_malabr/read_server_uds_extension/popup.js index 4974eb1e261b3b..ece685f2020e08 100644 --- a/addition_malabr/read_server_uds_extension/popup.js +++ b/addition_malabr/read_server_uds_extension/popup.js @@ -1,10 +1,10 @@ import { flatbuffers } from './flatbuffers.js'; import QAService from './qa_schema_generated.js'; -console.log('flatbuffers:', flatbuffers); -console.log('QAService:', QAService); -console.log('QAService.Payloads:', QAService.Payloads); -console.log('QAService.Payloads.QARequest:', QAService.Payloads?.QARequest); +// console.log('flatbuffers:', flatbuffers); +// console.log('QAService:', QAService); +// console.log('QAService.Payloads:', QAService.Payloads); +// console.log('QAService.Payloads.QARequest:', QAService.Payloads?.QARequest); // READ DATA const readDataBtnEle = document.getElementById('readDataBtn'); @@ -189,46 +189,20 @@ singleBertInferBtnEle.addEventListener('click', () => { return; } - // Create FlatBuffer payload - // console.log("Bert Infer Paylod", question, context); const flatbufferPayload = createQARequestBuffer(question, context); - // console.log("Flatbuffer Payload", flatbufferPayload); - // Normal json to uint8array - // const jsonPayload = JSON.stringify({ question, context }); - // const encoder = new TextEncoder(); - // const uint8ArrayPayload = encoder.encode(jsonPayload); - - // console.log("Bert Infer Paylod", jsonPayload); - - chrome.readServerUds.inferSingleBERT({ payload: flatbufferPayload, fb_id: "QASV"}, (response) => { + chrome.readServerUds.inferSingleBERT({ payload: flatbufferPayload, fb_id: "QASV" }, (response) => { if (chrome.runtime.lastError) { bertInputErrorEle.textContent = 'Native Error: ' + chrome.runtime.lastError.message; bertInputErrorEle.classList.add('error'); return; } - // flatbuffers - - // Expect binary response — decode with FlatBuffers instead of JSON.parse - // const bytes = new Uint8Array(response); - // const buf = new flatbuffers.ByteBuffer(bytes); - // const root = QAService.Payloads.Root.getRootAsRoot(buf); - - // if (root.payloadType() === QAService.Payloads.AnyPayload.QAResponse) { - // const qaResp = root.payload(new QAService.Payloads.QAResponse()); - // singleBertInferResponseEle.textContent = qaResp.answer(); - // } else { - // bertInputErrorEle.textContent = 'Unexpected payload type in response.'; - // bertInputErrorEle.classList.add('error'); - // } - - // Normal JSON on response = JSON.parse(response) if (response.status == "ok") { singleBertInferResponseEle.textContent = response.message; - } else if(response.status == "error") { + } else if (response.status == "error") { singleBertInferResponseEle.textContent = response.message; bertInputErrorEle.classList.add('error'); } else { @@ -237,3 +211,204 @@ singleBertInferBtnEle.addEventListener('click', () => { } }); }); + +function inferSingleBERTAsync(args) { + return new Promise((resolve, reject) => { + try { + chrome.readServerUds.inferSingleBERT(args, (result) => { + resolve(result); + }); + } catch (err) { + reject(err); + } + }); +} + +// SINGLE INFERENCE BENCHMARK BERT +const singleBertInferBenchmarkBtnEle = document.getElementById('singleBertBenchmarkBtn'); +const singleBertInferBenchmarkIterationEle = document.getElementById('singleBertInferBenchmarkIteration'); +const singleBertInferBenchmarkIterationTimeEle = document.getElementById('singleBertInferBenchmarkIterationTime'); +const NO_OF_INTERATION = 1000 +const NO_OF_WARMUP_INTERATION = 100 + +singleBertInferBenchmarkBtnEle.addEventListener('click', async () => { + // Define fixed question and context + const question = "when was iit kgp founded?"; + const context = ` +The Indian Institute of Technology Kharagpur (IIT Kharagpur or IIT-KGP) is a public institute of technology, research university, and autonomous institute established by the Government of India in Kharagpur, West Bengal. Founded in 1951, the institute is the first of the IITs to be established and is recognised as an Institute of National Importance. In 2019 it was awarded the status of Institute of Eminence by the Government of India.[4] + +The institute was initially established to train engineers after India attained independence in 1947. However, over the years, the institute's academic capabilities diversified with offerings in management, law, architecture, humanities, medicine, etc. The institute has an 8.7-square-kilometre (2,100-acre) campus and has about 22,000 residents. + +Foundation + +Nalini Ranjan Sarkar, who recommended the set up of IIT's, along the lines of MIT +In 1946, a committee was set up by Sir Jogendra Singh, Member of the Viceroy's executive council, to consider the creation of higher technical institutions for the industrial development of India post World War II. This was followed by the creation of a 22-member committee headed by Nalini Ranjan Sarkar. In its interim report, the Sarkar Committee recommended the establishment of higher technical institutions in India, along the lines of the Massachusetts Institute of Technology and consulting from the University of Illinois at Urbana Champaign along with affiliated secondary institutions. The report urged that work should start with the speedy establishment of major institutions in the four-quarters of the country with the ones in the east and the west to be set up immediately.[6] + + +Jawaharlal Nehru laying the foundation stone in 1951 +IIT Kharagpur Main Gate +IIT Kharagpur Main Entrance +IIT Kharagpur Main Entrance Gate +IIT Kharagpur Main Entrance Gate (Puri Gate) +On the grounds that West Bengal had the highest concentration of industries at the time, Bidhan Chandra Roy, the Chief Minister of West Bengal, persuaded Jawaharlal Nehru (India's first prime minister) to establish the first institute in West Bengal. The first Indian Institute of Technology was thus established in May 1950 as the Eastern Higher Technical Institute.[7] It was located in Esplanade East, Calcutta, and in September 1950 shifted to its permanent campus at Hijli, Kharagpur 120 kilometres (75 mi) south-west of Kolkata (formerly called Calcutta). Hijli had been used as a detention camp during the period of British rule in India, where Indian independence activists were imprisoned.[8] + +IIT Kharagpur is the 4th oldest technical institute in the state after IIEST, Shibpur (established as B.E. College in 1856), Jadavpur University (established as the Bengal Technical Institute in 1906) and Rajabazar Science College (established as Calcutta University campus for Science and Technology in 1914). When the first session started in August 1951, there were 224 students and 42 teachers in the ten departments of the institute. The classrooms, laboratories and the administrative office were housed in the historic building of the Hijli Detention Camp (now known as Shaheed Bhawan), where political revolutionaries were imprisoned during the period of British colonial rule.[9] The office building had served as the headquarters of the Bomber Command of the U.S. 20th Air Force during World War II. + + +IIT Kharagpur main building +Early developments + +The Hijli Detention Camp (photographed in 1951) served as IIT Kharagpur's first academic building +The name "Indian Institute of Technology" was adopted before the formal inauguration of the institute on 18 August 1951 by Maulana Abul Kalam Azad.[10] On 18 May 1956, a Bill (Bill no 36 of 1956)[11] was introduced in Lok Sabha to declare the institution known as the Indian Institute of Technology Kharagpur to be an institution of national importance and to provide for its incorporation and matters connected therewith. The motto of the institute, योगः कर्मसु कौशलम् is taken from the Bhagavad Gita, Chapter 2, Verse 50, and it has been translated by Sri Aurobindo as "Excellence in action is Yoga".[5] On 15 September 1956, the Indian Institute of Technology (Kharagpur) Act, 195 of Parliament received the assent of the President.[12] Prime Minister Nehru, in the first convocation address of IIT Kharagpur, said:[13] + +Here in the place of that Hijli Detention Camp stands the fine monument of India, representing India's urges, India's future in the making. This picture seems to me symbolical of the changes that are coming to India. + + +The main building of the institute during construction (1955) + +Nalanda Complex, 2018 +The Srinivasa Ramanujan Complex was incorporated as another academic complex of the institute with Takshashila starting operation in 2002, Vikramshila in 2003, and Nalanda in 2012. The erstwhile Hijli Detention camp building, subsequently renamed as the Hijli Saheed Bhavan, hosts the Nehru Museum of Science & Technology and is an imposing building bearing resemblance to the Byzantine style of architecture.[14] + +Nehru Museum + `; + + const flatbufferPayload = createQARequestBuffer(question, context); + + // await benchmarkWithSequential({ payload: flatbufferPayload, fb_id: "QASV" }, 50, 5); + // await benchmarkBurst({ payload: flatbufferPayload, fb_id: "QASV" }, 50, 5); + await benchmarkWithConcurrency({ payload: flatbufferPayload, fb_id: "QASV" }, 50, 10, 5); +}); + +async function benchmarkWithConcurrency(payload, iterations, poolSize, warmup = 10) { + // Warmup calls (not measured) + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + let completed = 0; + let inFlight = 0; + const latencies = []; + + return new Promise((resolve) => { + function launchNext() { + // stop condition: all iterations launched and completed + if (completed >= iterations && inFlight === 0) { + // Compute stats + latencies.sort((a, b) => a - b); + const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + const p99 = latencies[Math.floor(latencies.length * 0.99)]; + + console.log(`Benchmark over ${iterations} iterations (concurrency=${poolSize}):`); + console.log(`Avg: ${avg.toFixed(2)} ms, Median: ${median.toFixed(2)} ms, P90: ${p90.toFixed(2)} ms, P99: ${p99.toFixed(2)} ms`); + + const result = `Benchmark (N=${iterations}, concurrency=${poolSize}):\n` + + `Avg: ${avg.toFixed(2)} ms\n` + + `Median: ${median.toFixed(2)} ms\n` + + `P90: ${p90.toFixed(2)} ms\n` + + `P99: ${p99.toFixed(2)} ms`; + + singleBertInferBenchmarkIterationEle.textContent = "Iteration: " + iterations; + singleBertInferBenchmarkIterationTimeEle.textContent = result; + alert(result); + + resolve(latencies); + return; + } + + if (completed >= iterations) { + return; // no more work to launch + } + + inFlight++; + const start = performance.now(); + + inferSingleBERTAsync(payload) + .then(() => { + latencies.push(performance.now() - start); + }) + .finally(() => { + inFlight--; + completed++; + launchNext(); // launch the next request + }); + } + + // Kick off initial pool + for (let i = 0; i < poolSize && i < iterations; i++) { + launchNext(); + } + }); +} + +async function benchmarkWithSequential(payload, iterations, warmup = 10) { + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + // Measurement: run a fixed number of iterations. + let latencies = []; + + for (let i = 0; i < iterations; i++) { + const startTime = performance.now(); + await inferSingleBERTAsync(payload); + const endTime = performance.now(); + latencies.push(endTime - startTime); + } + + // Compute statistics. + latencies.sort((a, b) => a - b); + const sum = latencies.reduce((acc, cur) => acc + cur, 0); + const avg = sum / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + + console.log("Benchmark results HTTP:"); + console.log(`Average latency: ${avg.toFixed(2)} ms`); + console.log(`Median latency: ${median.toFixed(2)} ms`); + console.log(`90th percentile latency: ${p90.toFixed(2)} ms`); + const result = `Benchmark over ${iterations} iterations:\nAverage: ${avg.toFixed(2)} ms\nMedian: ${median.toFixed(2)} ms\n90th Percentile: ${p90.toFixed(2)} ms` + alert(result); +} + +async function benchmarkBurst(payload, iterations, warmup = 10) { + // Warmup (not measured) + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + // Launch all requests in parallel + const startTimes = new Array(iterations); + const promises = []; + + for (let i = 0; i < iterations; i++) { + startTimes[i] = performance.now(); + promises.push( + inferSingleBERTAsync(payload) + .then(() => performance.now() - startTimes[i]) + ); + } + + const latencies = await Promise.all(promises); + + // Stats + latencies.sort((a, b) => a - b); + const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + const p99 = latencies[Math.floor(latencies.length * 0.99)]; + + console.log(`Burst benchmark over ${iterations} parallel requests:`); + console.log(`Avg: ${avg.toFixed(2)} ms, Median: ${median.toFixed(2)} ms, P90: ${p90.toFixed(2)} ms, P99: ${p99.toFixed(2)} ms`); + + const result = `Burst Benchmark (N=${iterations}):\n` + + `Avg: ${avg.toFixed(2)} ms\n` + + `Median: ${median.toFixed(2)} ms\n` + + `P90: ${p90.toFixed(2)} ms\n` + + `P99: ${p99.toFixed(2)} ms`; + + alert(result); + + return latencies; +} \ No newline at end of file diff --git a/addition_malabr/reading server extension/popup.html b/addition_malabr/reading server extension/popup.html index 544de0bbf585f6..1f0e6cbeec8f54 100644 --- a/addition_malabr/reading server extension/popup.html +++ b/addition_malabr/reading server extension/popup.html @@ -57,8 +57,8 @@

MALABR - MobileBERT QA

Single Inference

- - + + @@ -69,6 +69,7 @@

Batch Inference

Benchmark Inference

+

Training

diff --git a/addition_malabr/reading server extension/popup.js b/addition_malabr/reading server extension/popup.js index eaa315afb2bcc4..41f33a69aa851b 100644 --- a/addition_malabr/reading server extension/popup.js +++ b/addition_malabr/reading server extension/popup.js @@ -4,14 +4,15 @@ document.addEventListener('DOMContentLoaded', function () { const inferBatchButton = document.getElementById('inferBatchButton'); const benchmarkInferenceButton = document.getElementById('benchmarkInferenceButton'); const trainModelButton = document.getElementById('trainModel'); - + const benchmarkInferenceResultEle = document.getElementById('benchmarkInferenceResult'); + // Inputs for single inference. const questionInput = document.getElementById('questionInput'); const contextInput = document.getElementById('contextInput'); - + // Input for batch inference (expects a JSON array). const batchInput = document.getElementById('batchInput'); - + // Load MobileBERT Model. if (loadModelBERTButton) { loadModelBERTButton.addEventListener('click', () => { @@ -34,7 +35,7 @@ document.addEventListener('DOMContentLoaded', function () { } else { console.error("Button with ID 'loadModelBERT' not found in DOM."); } - + // Single Inference. if (inferSingleButton && questionInput && contextInput) { inferSingleButton.addEventListener('click', () => { @@ -66,7 +67,7 @@ document.addEventListener('DOMContentLoaded', function () { } else { console.error("Single inference elements not found in DOM."); } - + // Batch Inference. if (inferBatchButton && batchInput) { inferBatchButton.addEventListener('click', () => { @@ -93,52 +94,207 @@ document.addEventListener('DOMContentLoaded', function () { } else { console.error("Batch inference elements not found in DOM."); } - + + function inferSingleBERTAsync(args) { + return new Promise((resolve, reject) => { + try { + chrome.readServer.inferSingleBERT(args, (result) => { + resolve(result); + }); + } catch (err) { + reject(err); + } + }); + } + + // Benchmark Inference. if (benchmarkInferenceButton) { benchmarkInferenceButton.addEventListener('click', async () => { + const NO_OF_INTERATION = 1000 + const NO_OF_WARMUP_INTERATION = 100 + // Define fixed question and context - const question = "What day was the game played on?"; - const context = "The game was played on February 7, 2016 at Levi's Stadium in the San Francisco Bay Area at Santa Clara, California."; - const payload = JSON.stringify({ question, context }); - - for (let i = 0; i < 100; i++) { - await new Promise(resolve => { - chrome.readServer.inferSingleBERT(payload, () => resolve()); - }); - } - - // Measurement: run a fixed number of iterations. - const iterations = 1000; - let latencies = []; - - for (let i = 0; i < iterations; i++) { - const startTime = performance.now(); - await new Promise(resolve => { - chrome.readServer.inferSingleBERT(payload, () => resolve()); - }); - const endTime = performance.now(); - latencies.push(endTime - startTime); - } - - // Compute statistics. - latencies.sort((a, b) => a - b); - const sum = latencies.reduce((acc, cur) => acc + cur, 0); - const avg = sum / latencies.length; - const median = latencies[Math.floor(latencies.length / 2)]; - const p90 = latencies[Math.floor(latencies.length * 0.9)]; - - console.log("Benchmark results:"); - console.log(`Average latency: ${avg.toFixed(2)} ms`); - console.log(`Median latency: ${median.toFixed(2)} ms`); - console.log(`90th percentile latency: ${p90.toFixed(2)} ms`); + const question = "when was iit kgp founded?"; + const context = ` +The Indian Institute of Technology Kharagpur (IIT Kharagpur or IIT-KGP) is a public institute of technology, research university, and autonomous institute established by the Government of India in Kharagpur, West Bengal. Founded in 1951, the institute is the first of the IITs to be established and is recognised as an Institute of National Importance. In 2019 it was awarded the status of Institute of Eminence by the Government of India.[4] + +The institute was initially established to train engineers after India attained independence in 1947. However, over the years, the institute's academic capabilities diversified with offerings in management, law, architecture, humanities, medicine, etc. The institute has an 8.7-square-kilometre (2,100-acre) campus and has about 22,000 residents. - alert(`Benchmark over ${iterations} iterations:\nAverage: ${avg.toFixed(2)} ms\nMedian: ${median.toFixed(2)} ms\n90th Percentile: ${p90.toFixed(2)} ms`); +Foundation + +Nalini Ranjan Sarkar, who recommended the set up of IIT's, along the lines of MIT +In 1946, a committee was set up by Sir Jogendra Singh, Member of the Viceroy's executive council, to consider the creation of higher technical institutions for the industrial development of India post World War II. This was followed by the creation of a 22-member committee headed by Nalini Ranjan Sarkar. In its interim report, the Sarkar Committee recommended the establishment of higher technical institutions in India, along the lines of the Massachusetts Institute of Technology and consulting from the University of Illinois at Urbana Champaign along with affiliated secondary institutions. The report urged that work should start with the speedy establishment of major institutions in the four-quarters of the country with the ones in the east and the west to be set up immediately.[6] + + +Jawaharlal Nehru laying the foundation stone in 1951 +IIT Kharagpur Main Gate +IIT Kharagpur Main Entrance +IIT Kharagpur Main Entrance Gate +IIT Kharagpur Main Entrance Gate (Puri Gate) +On the grounds that West Bengal had the highest concentration of industries at the time, Bidhan Chandra Roy, the Chief Minister of West Bengal, persuaded Jawaharlal Nehru (India's first prime minister) to establish the first institute in West Bengal. The first Indian Institute of Technology was thus established in May 1950 as the Eastern Higher Technical Institute.[7] It was located in Esplanade East, Calcutta, and in September 1950 shifted to its permanent campus at Hijli, Kharagpur 120 kilometres (75 mi) south-west of Kolkata (formerly called Calcutta). Hijli had been used as a detention camp during the period of British rule in India, where Indian independence activists were imprisoned.[8] + +IIT Kharagpur is the 4th oldest technical institute in the state after IIEST, Shibpur (established as B.E. College in 1856), Jadavpur University (established as the Bengal Technical Institute in 1906) and Rajabazar Science College (established as Calcutta University campus for Science and Technology in 1914). When the first session started in August 1951, there were 224 students and 42 teachers in the ten departments of the institute. The classrooms, laboratories and the administrative office were housed in the historic building of the Hijli Detention Camp (now known as Shaheed Bhawan), where political revolutionaries were imprisoned during the period of British colonial rule.[9] The office building had served as the headquarters of the Bomber Command of the U.S. 20th Air Force during World War II. + + +IIT Kharagpur main building +Early developments + +The Hijli Detention Camp (photographed in 1951) served as IIT Kharagpur's first academic building +The name "Indian Institute of Technology" was adopted before the formal inauguration of the institute on 18 August 1951 by Maulana Abul Kalam Azad.[10] On 18 May 1956, a Bill (Bill no 36 of 1956)[11] was introduced in Lok Sabha to declare the institution known as the Indian Institute of Technology Kharagpur to be an institution of national importance and to provide for its incorporation and matters connected therewith. The motto of the institute, योगः कर्मसु कौशलम् is taken from the Bhagavad Gita, Chapter 2, Verse 50, and it has been translated by Sri Aurobindo as "Excellence in action is Yoga".[5] On 15 September 1956, the Indian Institute of Technology (Kharagpur) Act, 195 of Parliament received the assent of the President.[12] Prime Minister Nehru, in the first convocation address of IIT Kharagpur, said:[13] + +Here in the place of that Hijli Detention Camp stands the fine monument of India, representing India's urges, India's future in the making. This picture seems to me symbolical of the changes that are coming to India. + + +The main building of the institute during construction (1955) + +Nalanda Complex, 2018 +The Srinivasa Ramanujan Complex was incorporated as another academic complex of the institute with Takshashila starting operation in 2002, Vikramshila in 2003, and Nalanda in 2012. The erstwhile Hijli Detention camp building, subsequently renamed as the Hijli Saheed Bhavan, hosts the Nehru Museum of Science & Technology and is an imposing building bearing resemblance to the Byzantine style of architecture.[14] + +Nehru Museum + `; + + const payload = JSON.stringify({ question, context }); + // await benchmarkWithSequential(payload, 50, 5); + // await benchmarkBurst(payload, 50, 5); + await benchmarkWithConcurrency(payload, 50, 10, 2); + }); } else { console.error("Button with ID 'benchmarkInferenceButton' not found in DOM."); } - + + async function benchmarkWithConcurrency(payload, iterations, poolSize, warmup = 10) { + // Warmup calls (not measured) + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + let completed = 0; + let inFlight = 0; + const latencies = []; + + return new Promise((resolve) => { + function launchNext() { + // stop condition: all iterations launched and completed + if (completed >= iterations && inFlight === 0) { + // Compute stats + latencies.sort((a, b) => a - b); + const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + const p99 = latencies[Math.floor(latencies.length * 0.99)]; + + console.log(`Benchmark over ${iterations} iterations (concurrency=${poolSize}):`); + console.log(`Avg: ${avg.toFixed(2)} ms, Median: ${median.toFixed(2)} ms, P90: ${p90.toFixed(2)} ms, P99: ${p99.toFixed(2)} ms`); + + const result = `Benchmark (N=${iterations}, concurrency=${poolSize}):\n` + + `Avg: ${avg.toFixed(2)} ms\n` + + `Median: ${median.toFixed(2)} ms\n` + + `P90: ${p90.toFixed(2)} ms\n` + + `P99: ${p99.toFixed(2)} ms`; + + alert(result); + + resolve(latencies); + return; + } + + if (completed >= iterations) { + return; // no more work to launch + } + + inFlight++; + const start = performance.now(); + + inferSingleBERTAsync(payload) + .then(() => { + latencies.push(performance.now() - start); + }) + .finally(() => { + inFlight--; + completed++; + launchNext(); // launch the next request + }); + } + + // Kick off initial pool + for (let i = 0; i < poolSize && i < iterations; i++) { + launchNext(); + } + }); + } + + async function benchmarkWithSequential(payload, iterations, warmup = 10) { + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + // Measurement: run a fixed number of iterations. + let latencies = []; + + for (let i = 0; i < iterations; i++) { + const startTime = performance.now(); + await inferSingleBERTAsync(payload); + const endTime = performance.now(); + latencies.push(endTime - startTime); + } + + // Compute statistics. + latencies.sort((a, b) => a - b); + const sum = latencies.reduce((acc, cur) => acc + cur, 0); + const avg = sum / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + + console.log("Benchmark results HTTP:"); + console.log(`Average latency: ${avg.toFixed(2)} ms`); + console.log(`Median latency: ${median.toFixed(2)} ms`); + console.log(`90th percentile latency: ${p90.toFixed(2)} ms`); + alert(result); + } + + async function benchmarkBurst(payload, iterations, warmup = 10) { + // Warmup (not measured) + for (let i = 0; i < warmup; i++) { + await inferSingleBERTAsync(payload); + } + + // Launch all requests in parallel + const startTimes = new Array(iterations); + const promises = []; + + for (let i = 0; i < iterations; i++) { + startTimes[i] = performance.now(); + promises.push( + inferSingleBERTAsync(payload) + .then(() => performance.now() - startTimes[i]) + ); + } + + const latencies = await Promise.all(promises); + + // Stats + latencies.sort((a, b) => a - b); + const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length; + const median = latencies[Math.floor(latencies.length / 2)]; + const p90 = latencies[Math.floor(latencies.length * 0.9)]; + const p99 = latencies[Math.floor(latencies.length * 0.99)]; + + console.log(`Burst benchmark over ${iterations} parallel requests:`); + console.log(`Avg: ${avg.toFixed(2)} ms, Median: ${median.toFixed(2)} ms, P90: ${p90.toFixed(2)} ms, P99: ${p99.toFixed(2)} ms`); + + const result = `Burst Benchmark (N=${iterations}):\n` + + `Avg: ${avg.toFixed(2)} ms\n` + + `Median: ${median.toFixed(2)} ms\n` + + `P90: ${p90.toFixed(2)} ms\n` + + `P99: ${p99.toFixed(2)} ms`; + + alert(result); + + return latencies; + } + // Training with client-side timing if (trainModelButton) { trainModelButton.addEventListener('click', () => { From f806eb3a1e306e0ef186c02ff8e8b00949707978 Mon Sep 17 00:00:00 2001 From: Bivas-Biswas Date: Tue, 26 Aug 2025 16:25:15 +0530 Subject: [PATCH 2/7] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20update:=20the=20server?= =?UTF-8?q?=20code=20make=20it=20only=20use=20threadpool?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../modelserver_uds/app/socket_server_v2.py | 102 +++++++----------- 1 file changed, 37 insertions(+), 65 deletions(-) diff --git a/addition_malabr/modelserver_uds/app/socket_server_v2.py b/addition_malabr/modelserver_uds/app/socket_server_v2.py index 1d7d330f60b380..67a50b993a6cd0 100644 --- a/addition_malabr/modelserver_uds/app/socket_server_v2.py +++ b/addition_malabr/modelserver_uds/app/socket_server_v2.py @@ -1,8 +1,7 @@ import socket -import select -import threading import struct import os +import threading from concurrent.futures import ThreadPoolExecutor from types_defs import Payload @@ -12,21 +11,23 @@ logger = get_logger(__name__) +MAX_HEADER = 8 * 1024 + class Server: - def __init__(self, sock_path: str, router: Router, max_workers=5): + def __init__(self, sock_path: str, router: Router, max_workers=10): self.sock_path = sock_path self.router = router self.max_workers = max_workers self.server_socket = None - self.epoll = None - self.connections = {} self.thread_pool = ThreadPoolExecutor(max_workers=self.max_workers) def start(self): self._setup_socket() print(f"[SERVER] Listening on {self.sock_path} with {self.max_workers} workers.") try: - self._event_loop() + while True: + conn, _ = self.server_socket.accept() + self.thread_pool.submit(self._handle_request, conn) except KeyboardInterrupt: print("\n[SERVER] Shutdown signal received.") finally: @@ -34,91 +35,62 @@ def start(self): def _setup_socket(self): if os.path.exists(self.sock_path): - os.remove(self.sock_path) - + os.remove(self.sock_path) + self.server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - self.server_socket.setblocking(False) self.server_socket.bind(self.sock_path) self.server_socket.listen(50) - self.epoll = select.epoll() - self.epoll.register(self.server_socket.fileno(), select.EPOLLIN) - - def _event_loop(self): - while True: - events = self.epoll.poll(1) - for fileno, event in events: - if fileno == self.server_socket.fileno(): - self._accept_connection() - elif event & select.EPOLLIN: - client_socket = self.connections.get(fileno) - if client_socket: - self.epoll.unregister(fileno) - del self.connections[fileno] - self.thread_pool.submit(self._worker_task, self.router, client_socket) - - - def _accept_connection(self): - conn, _ = self.server_socket.accept() - conn.setblocking(False) - self.epoll.register(conn.fileno(), select.EPOLLIN) - self.connections[conn.fileno()] = conn - - def recv_exact(self, conn: socket.socket, n: int): - """Read exactly n bytes from the socket.""" - buf = b"" - while len(buf) < n: - chunk = conn.recv(n - len(buf)) - if not chunk: - raise ConnectionError("Socket closed unexpectedly") - buf += chunk - return buf - - def _worker_task(self, router: Router, conn: socket.socket): - """Worker task now reads the header and routes with the payload.""" + + def _handle_request(self, conn: socket.socket): try: - conn.setblocking(True) - - # Step 1: Read 4-byte header length - raw_len = self.recv_exact(conn, 4) + raw_len = self._recv_exact(conn, 4) header_len = struct.unpack("!I", raw_len)[0] - # Step 2: Read header - header_bytes = self.recv_exact(conn, header_len) + header_bytes = self._recv_exact(conn, header_len) header_str = header_bytes.decode("utf-8") fb_id, label, payload_size_str = header_str.split(",") payload_size = int(payload_size_str) - logger.debug(f"[WORK_IDENTIFIER:{threading.get_ident()}] Header received: fb_id={fb_id}, label={label}, payload_size={payload_size}") + payload_bytes = self._recv_exact(conn, payload_size) - # Step 3: Read payload - payload_bytes = self.recv_exact(conn, payload_size) - - # Step 4: Format the payload payload: Payload = { "label": label, "payload_bytes": payload_bytes, "fb_id": fb_id, - "payload_size": payload_size + "payload_size": payload_size, } - - handler = router.get_handler(label) + + handler = self.router.get_handler(label) if not handler: - logger.error(f"[WORKER:{threading.get_ident()}] No handler for label {label}") respond(conn, "error", f"Unknown label: {label}") return - + handler(conn, payload) - except Exception as e: - print(f"[WORK_IDENTIFIER:{threading.get_ident()}] Error during task execution: {e}") + logger.error(f"[Worker:{threading.get_ident()}] Error: {e}") + try: + respond(conn, "error", str(e)) + except Exception: + pass finally: conn.close() + def _recv_exact(self, conn: socket.socket, n: int) -> bytes: + buf = b"" + while len(buf) < n: + chunk = conn.recv(n - len(buf)) + if not chunk: + raise ConnectionError("Socket closed unexpectedly") + buf += chunk + return buf + def _shutdown(self): - os.remove(self.sock_path) + try: + os.remove(self.sock_path) + except FileNotFoundError: + pass self.thread_pool.shutdown(wait=True) - self.epoll.close() self.server_socket.close() - print("[SERVER] Shutdown complete.") \ No newline at end of file + print("[SERVER] Shutdown complete.") From b48f7a715973d1e6fc19414f9e3237a898636820 Mon Sep 17 00:00:00 2001 From: Sujan Jain Date: Sat, 30 Aug 2025 00:01:53 +0530 Subject: [PATCH 3/7] Benchmark files --- .../modelserver_uds/app/types_defs.py | 20 ++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/addition_malabr/modelserver_uds/app/types_defs.py b/addition_malabr/modelserver_uds/app/types_defs.py index 2cd226008e8f03..6c3515f367cbd9 100644 --- a/addition_malabr/modelserver_uds/app/types_defs.py +++ b/addition_malabr/modelserver_uds/app/types_defs.py @@ -1,19 +1,21 @@ import socket from typing import Literal, TypedDict, Callable, Dict +LabelType = Literal[ + "LABEL_READ_DATA", + "LABEL_SEND_DATA", + "LABEL_LOAD_MODEL_BERT", + "LABEL_INFER_MODEL_BERT" +] + class Payload(TypedDict): - label: Literal[ - 'LABEL_READ_DATA', - 'LABEL_SEND_DATA', - 'LABEL_LOAD_MODEL_BERT', - 'LABEL_INFER_MODEL_BERT' - ] + label: LabelType payload_bytes: bytes payload_size: int fb_id: str - + HandlerType = Callable[[socket.socket, Payload], None] +RoutesType = Dict[LabelType, HandlerType] -RoutesType = Dict[Payload["label"], HandlerType] +RespondStatus = Literal["ok", "error"] -RespondStatus = Literal["ok", "error"] From b900807f38cbbd64d6cb331c7ed4576b8ca35291 Mon Sep 17 00:00:00 2001 From: Sujan Jain Date: Sat, 30 Aug 2025 00:04:04 +0530 Subject: [PATCH 4/7] Benchmark files --- addition_malabr/benchmark_data/100kb.txt | 3 +++ addition_malabr/benchmark_data/10kb.txt | 2 ++ addition_malabr/benchmark_data/30kb.txt | 2 ++ addition_malabr/benchmark_data/50kb.txt | 2 ++ addition_malabr/benchmark_data/70kb.txt | 2 ++ 5 files changed, 11 insertions(+) create mode 100644 addition_malabr/benchmark_data/100kb.txt create mode 100644 addition_malabr/benchmark_data/10kb.txt create mode 100644 addition_malabr/benchmark_data/30kb.txt create mode 100644 addition_malabr/benchmark_data/50kb.txt create mode 100644 addition_malabr/benchmark_data/70kb.txt diff --git a/addition_malabr/benchmark_data/100kb.txt b/addition_malabr/benchmark_data/100kb.txt new file mode 100644 index 00000000000000..112d0219da464c --- /dev/null +++ b/addition_malabr/benchmark_data/100kb.txt @@ -0,0 +1,3 @@ +question: what is my name ? +context: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 + diff --git a/addition_malabr/benchmark_data/10kb.txt b/addition_malabr/benchmark_data/10kb.txt new file mode 100644 index 00000000000000..338be7d06b7f92 --- /dev/null +++ b/addition_malabr/benchmark_data/10kb.txt @@ -0,0 +1,2 @@ +question: what is my name ? +context: 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 \ No newline at end of file diff --git a/addition_malabr/benchmark_data/30kb.txt b/addition_malabr/benchmark_data/30kb.txt new file mode 100644 index 00000000000000..ac285599b96c2d --- /dev/null +++ b/addition_malabr/benchmark_data/30kb.txt @@ -0,0 +1,2 @@ +question: what is my name ? +context: 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 \ No newline at end of file diff --git a/addition_malabr/benchmark_data/50kb.txt b/addition_malabr/benchmark_data/50kb.txt new file mode 100644 index 00000000000000..fccfdf2f875ebe --- /dev/null +++ b/addition_malabr/benchmark_data/50kb.txt @@ -0,0 +1,2 @@ +question: what is my name ? +context: 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 \ No newline at end of file diff --git a/addition_malabr/benchmark_data/70kb.txt b/addition_malabr/benchmark_data/70kb.txt new file mode 100644 index 00000000000000..10629496dcf6e3 --- /dev/null +++ b/addition_malabr/benchmark_data/70kb.txt @@ -0,0 +1,2 @@ +question: what is my name ? +context: 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 \ No newline at end of file From 996c126984ebbf6251276155b9c8a20fdc33c655 Mon Sep 17 00:00:00 2001 From: Bivas-Biswas Date: Sat, 30 Aug 2025 12:49:22 +0530 Subject: [PATCH 5/7] =?UTF-8?q?=E2=9C=85=20added:=20chunking=20support=20f?= =?UTF-8?q?or=20send=20the=20data?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../api/read_server_uds/ml_server_uds.cc | 56 ++++++++++++++++--- .../api/read_server_uds/ml_server_uds.h | 9 +++ 2 files changed, 57 insertions(+), 8 deletions(-) diff --git a/extensions/browser/api/read_server_uds/ml_server_uds.cc b/extensions/browser/api/read_server_uds/ml_server_uds.cc index a409074d80beaa..33faf439fa2190 100644 --- a/extensions/browser/api/read_server_uds/ml_server_uds.cc +++ b/extensions/browser/api/read_server_uds/ml_server_uds.cc @@ -138,7 +138,10 @@ void MLServerUDS::OnConnected(int result) { return; } - LOG(INFO) << "OnConnected: sending the payload "; + LOG(INFO) << "OnConnected: sending the payload in chunks"; + + // reset chunk state + bytes_sent_ = 0; net::NetworkTrafficAnnotationTag annotation = net::DefineNetworkTrafficAnnotation("ml_server_uds_write", R"( @@ -154,17 +157,31 @@ void MLServerUDS::OnConnected(int result) { setting: "This cannot be disabled in settings." })"); + // kick off first chunk write + WriteNextChunk(annotation); +} + +void MLServerUDS::WriteNextChunk( + const net::NetworkTrafficAnnotationTag& annotation) { + constexpr size_t kChunkSize = 64 * 1024; // 64 KB + size_t remaining = payload_size_ - bytes_sent_; + size_t to_send = std::min(kChunkSize, remaining); + + auto buf = base::MakeRefCounted(to_send); + memcpy(buf->data(), payload_->data() + bytes_sent_, to_send); + int write_result = - socket_->Write(payload_.get(), payload_size_, - base::BindOnce(&MLServerUDS::OnDataWritten, - weak_ptr_factory_.GetWeakPtr()), + socket_->Write(buf.get(), to_send, + base::BindOnce(&MLServerUDS::OnChunkWritten, + weak_ptr_factory_.GetWeakPtr(), + buf, to_send, annotation), annotation); - if (write_result == static_cast(payload_->size())) { - LOG(INFO) << "Write synchronous"; - OnDataWritten(write_result); + if (write_result == static_cast(to_send)) { + LOG(INFO) << "Chunk write synchronous, size=" << to_send; + OnChunkWritten(buf, to_send, annotation, write_result); } else if (write_result == net::ERR_IO_PENDING) { - LOG(INFO) << "Write pending"; + LOG(INFO) << "Chunk write pending, size=" << to_send; } else { LOG(ERROR) << "Write failed: " << write_result; content::GetUIThreadTaskRunner({})->PostTask( @@ -172,6 +189,29 @@ void MLServerUDS::OnConnected(int result) { } } +void MLServerUDS::OnChunkWritten( + scoped_refptr buf, + size_t expected, + const net::NetworkTrafficAnnotationTag& annotation, + int result) { + if (result < 0) { + LOG(ERROR) << "Chunk write failed: " << result; + content::GetUIThreadTaskRunner({})->PostTask( + FROM_HERE, base::BindOnce(std::move(error_callback_), "Write failed")); + return; + } + + bytes_sent_ += result; + LOG(INFO) << "Chunk written: " << result << " bytes, total=" << bytes_sent_; + + if (bytes_sent_ < payload_size_) { + WriteNextChunk(annotation); // write next piece + } else { + LOG(INFO) << "All payload written (" << bytes_sent_ << " bytes)"; + OnDataWritten(bytes_sent_); + } +} + void MLServerUDS::OnDataWritten(int result) { if (result <= 0) { LOG(ERROR) << "Write error: " << result; diff --git a/extensions/browser/api/read_server_uds/ml_server_uds.h b/extensions/browser/api/read_server_uds/ml_server_uds.h index 5c296a7c9aa505..74570c7a9e6e5c 100644 --- a/extensions/browser/api/read_server_uds/ml_server_uds.h +++ b/extensions/browser/api/read_server_uds/ml_server_uds.h @@ -37,6 +37,14 @@ class MLServerUDS { void OnHeaderSend(int result); void OnConnected(int result); void OnDataWritten(int result); + // Write next 64KB chunk + void WriteNextChunk(const net::NetworkTrafficAnnotationTag& annotation); + + // Called when a chunk write completes + void OnChunkWritten(scoped_refptr buf, + size_t expected, + const net::NetworkTrafficAnnotationTag& annotation, + int result); void OnDataRead(int result); std::string GetHeaderPayload(); std::string CreateJSONStringPayload(const std::string& label, @@ -46,6 +54,7 @@ class MLServerUDS { std::string socket_path_; scoped_refptr payload_; size_t payload_size_; + size_t bytes_sent_ = 0; std::string fb_file_identifier_; std::string label_; std::string model_name_; From 8c1260c7b7c61b59268bd21bf42ac77c38e4f7a4 Mon Sep 17 00:00:00 2001 From: Bivas-Biswas Date: Sat, 30 Aug 2025 15:09:27 +0530 Subject: [PATCH 6/7] =?UTF-8?q?=E2=9C=85=20some=20udpate?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../api/read_server_uds/ml_server_uds.cc | 107 ++++++++++++------ 1 file changed, 73 insertions(+), 34 deletions(-) diff --git a/extensions/browser/api/read_server_uds/ml_server_uds.cc b/extensions/browser/api/read_server_uds/ml_server_uds.cc index 33faf439fa2190..8fc2325f1b6c18 100644 --- a/extensions/browser/api/read_server_uds/ml_server_uds.cc +++ b/extensions/browser/api/read_server_uds/ml_server_uds.cc @@ -1,8 +1,9 @@ #include "extensions/browser/api/read_server_uds/ml_server_uds.h" -#include #include +#include + #include "base/json/json_reader.h" #include "base/json/json_writer.h" #include "base/logging.h" @@ -23,12 +24,14 @@ MLServerUDS::~MLServerUDS() { DCHECK(!socket_) << "Socket must be cleared before destruction!"; } -void MLServerUDS::Send(scoped_refptr payload, size_t payload_size, std::string fb_file_identifier, +void MLServerUDS::Send(scoped_refptr payload, + size_t payload_size, + std::string fb_file_identifier, base::OnceCallback success_cb, base::OnceCallback error_cb) { payload_ = payload; payload_size_ = payload_size; - fb_file_identifier_= fb_file_identifier; + fb_file_identifier_ = fb_file_identifier; success_callback_ = std::move(success_cb); error_callback_ = std::move(error_cb); @@ -83,19 +86,20 @@ void MLServerUDS::ConnectToUnixSocket() { } } -void MLServerUDS::OnHeaderSend(int result){ +void MLServerUDS::OnHeaderSend(int result) { if (result != net::OK) { LOG(ERROR) << "OnHeaderSend: Socket connection failed: " << result; content::GetUIThreadTaskRunner({})->PostTask( - FROM_HERE, - base::BindOnce(std::move(error_callback_), "OnHeaderSend: Socket connection failed")); + FROM_HERE, base::BindOnce(std::move(error_callback_), + "OnHeaderSend: Socket connection failed")); return; } std::string header_payload = GetHeaderPayload(); LOG(INFO) << "Socket connected, sending the header "; - auto header_buffer = base::MakeRefCounted(header_payload); + auto header_buffer = + base::MakeRefCounted(header_payload); net::NetworkTrafficAnnotationTag annotation = net::DefineNetworkTrafficAnnotation("ml_server_uds_sending_header", R"( @@ -111,11 +115,10 @@ void MLServerUDS::OnHeaderSend(int result){ setting: "This cannot be disabled in settings." })"); - int write_result = - socket_->Write(header_buffer.get(), header_buffer->size(), - base::BindOnce(&MLServerUDS::OnConnected, - weak_ptr_factory_.GetWeakPtr()), - annotation); + int write_result = socket_->Write( + header_buffer.get(), header_buffer->size(), + base::BindOnce(&MLServerUDS::OnConnected, weak_ptr_factory_.GetWeakPtr()), + annotation); if (write_result == static_cast(header_buffer->size())) { LOG(INFO) << "OnConnected: Header Write synchronous"; @@ -125,7 +128,8 @@ void MLServerUDS::OnHeaderSend(int result){ } else { LOG(ERROR) << "Header Write failed: " << write_result; content::GetUIThreadTaskRunner({})->PostTask( - FROM_HERE, base::BindOnce(std::move(error_callback_), "Header Write failed")); + FROM_HERE, + base::BindOnce(std::move(error_callback_), "Header Write failed")); } } @@ -163,23 +167,30 @@ void MLServerUDS::OnConnected(int result) { void MLServerUDS::WriteNextChunk( const net::NetworkTrafficAnnotationTag& annotation) { - constexpr size_t kChunkSize = 64 * 1024; // 64 KB + constexpr size_t kChunkSize = 10 * 1024; // 64 KB size_t remaining = payload_size_ - bytes_sent_; size_t to_send = std::min(kChunkSize, remaining); auto buf = base::MakeRefCounted(to_send); memcpy(buf->data(), payload_->data() + bytes_sent_, to_send); - int write_result = - socket_->Write(buf.get(), to_send, - base::BindOnce(&MLServerUDS::OnChunkWritten, - weak_ptr_factory_.GetWeakPtr(), - buf, to_send, annotation), - annotation); + // int write_result = socket_->Write( + // header_buffer.get(), header_buffer->size(), + // base::BindOnce(&MLServerUDS::OnConnected, + // weak_ptr_factory_.GetWeakPtr()), annotation); + int write_result = socket_->Write( + buf.get(), to_send, + base::BindOnce(&MLServerUDS::OnChunkWritten, + weak_ptr_factory_.GetWeakPtr(), buf, to_send, annotation), + annotation); if (write_result == static_cast(to_send)) { LOG(INFO) << "Chunk write synchronous, size=" << to_send; OnChunkWritten(buf, to_send, annotation, write_result); + } else if (write_result > 0 && write_result < static_cast(to_send)) { + LOG(WARNING) << "Partial write synchronous: " << write_result << " of " + << to_send; + OnChunkWritten(buf, to_send, annotation, write_result); } else if (write_result == net::ERR_IO_PENDING) { LOG(INFO) << "Chunk write pending, size=" << to_send; } else { @@ -195,17 +206,43 @@ void MLServerUDS::OnChunkWritten( const net::NetworkTrafficAnnotationTag& annotation, int result) { if (result < 0) { - LOG(ERROR) << "Chunk write failed: " << result; + LOG(ERROR) << "Write failed: " << result; content::GetUIThreadTaskRunner({})->PostTask( FROM_HERE, base::BindOnce(std::move(error_callback_), "Write failed")); return; } + if (result < static_cast(expected)) { + // Partial write: retry the rest + LOG(WARNING) << "Partial write: only " << result << " of " << expected + << " bytes written. Retrying remainder."; + + size_t remaining = expected - result; + + // don't advance bytes_sent_ yet, only when full chunk is done + auto remainder = base::MakeRefCounted(remaining); + memcpy(remainder->data(), buf->data() + result, remaining); + + int write_result = + socket_->Write(remainder.get(), remaining, + base::BindOnce(&MLServerUDS::OnChunkWritten, + weak_ptr_factory_.GetWeakPtr(), remainder, + remaining, annotation), + annotation); + + if (write_result >= 0 && write_result < static_cast(remaining)) { + // schedule async retry, don't recurse + return; + } + return; + } + + // Full chunk successfully written bytes_sent_ += result; LOG(INFO) << "Chunk written: " << result << " bytes, total=" << bytes_sent_; if (bytes_sent_ < payload_size_) { - WriteNextChunk(annotation); // write next piece + WriteNextChunk(annotation); } else { LOG(INFO) << "All payload written (" << bytes_sent_ << " bytes)"; OnDataWritten(bytes_sent_); @@ -267,22 +304,24 @@ std::string MLServerUDS::CreateJSONStringPayload(const std::string& label, } std::string MLServerUDS::GetHeaderPayload() { - // 1. Construct the header string - std::string header = fb_file_identifier_ + "," + label_ + "," + std::to_string(payload_size_); + // 1. Construct the header string + std::string header = + fb_file_identifier_ + "," + label_ + "," + std::to_string(payload_size_); - // 2. Compute its length - uint32_t header_len = static_cast(header.size()); + // 2. Compute its length + uint32_t header_len = static_cast(header.size()); - // 3. Convert length to network byte order (big endian) - uint32_t header_len_net = htonl(header_len); + // 3. Convert length to network byte order (big endian) + uint32_t header_len_net = htonl(header_len); - // 4. Build final output: 4-byte length prefix + header - std::string out; - out.reserve(sizeof(header_len_net) + header.size()); - out.append(reinterpret_cast(&header_len_net), sizeof(header_len_net)); - out.append(header); + // 4. Build final output: 4-byte length prefix + header + std::string out; + out.reserve(sizeof(header_len_net) + header.size()); + out.append(reinterpret_cast(&header_len_net), + sizeof(header_len_net)); + out.append(header); - return out; + return out; } } // namespace extensions From c31b35c488b60b6a0eb3383ab6d08abe4409f7f8 Mon Sep 17 00:00:00 2001 From: Sujan Jain Date: Sun, 31 Aug 2025 15:25:49 +0530 Subject: [PATCH 7/7] Run1 added --- .../api/read_server_uds/flatbuffer_data.bin | Bin 0 -> 10320 bytes .../read_server_uds/read_server_uds_api.cc | 53 ++++++++++++++++++ .../api/read_server_uds/read_server_uds_api.h | 1 + 3 files changed, 54 insertions(+) create mode 100644 extensions/browser/api/read_server_uds/flatbuffer_data.bin diff --git a/extensions/browser/api/read_server_uds/flatbuffer_data.bin b/extensions/browser/api/read_server_uds/flatbuffer_data.bin new file mode 100644 index 0000000000000000000000000000000000000000..17bcae70066d6813aa820a22d3a58128b58c40c5 GIT binary patch literal 10320 zcmXY%$&R%;mW6LgB~=b`ko5+4SZ`4>eP=LW+8KRs3><^)r%(T-I-$^sI3W?>X79DW z<$wM4*IzM6^MCyH&%gfbuYaho|9kz%Kh@ix&;IlOKl|7J{H1r*nGYP$3-7^adc{;FTKLfW-oW16wLfUi`T`?tqtBA#FS3JauvoBai7QjF zqTx!aN&NOHo{cH%np(4XvLERzO31>~+RI4u@i&Ut8)y=Qca*=*=v!I)3+wHD_eKb- zdh)8ihZ}B`TtPN@lJei8Xa3%eJCx>O8k56IOV_8oxNNLrTb?#g4|Qi*$Gm!ZT8&XZ zjSnl1@YV_A7j*LY5%VXX%nm2dVpgC2is?QdR8S1Y2cMg;@of%fFLpv>;~mH5M_`$) zMr0oOc1~;L$6muKY%X~Ne9=0;t{LV2&24>dd(PPbFdxOmoW%#|c^#8v!rFZoZ&A?Z z5^j*EJV}1L`}x_<@a`4n1F0YMwl9&)U#ks`7qPMf^Wm4AesP%3g}e8~yGQW6>XWjB>_Day%j_FT z&5imx@f^o%>uLE+`5S-zWEUb9{nBN1mn7Z6ZAP4Jl%ErUF^}He^@zcT=S3&*KjV8* z3p`TUP1%$Nan2_W6LC;|;z03w40a^KJH8m{zmw zhN)Ie-aMw7@K7WKXU0=5t_?ru=5cR1c`^Q`bz(K9IxI{p(fRYdnXzSgPz`nU%@}CE z7^S;2l?4PN?~KfeAMd_=Ih(yrvecaS*UrB({eTQVGh)f(6XRF?Xp$~#R*23eXdJah zJ$h_LW_CV2Gr2wZ?^|kgpj&yh)^84w)%`wkS_$wx!v$=3Sc%svYtG?2vOBLow~Pdi zKeyG6iF@;O+P@eFW-B%4 zS^Av8vi{kV5l?M`n`8UsZg?A2k{zUPkg#L|Y+4UaZbuo(=*ylUH$JhnM33}eonofS z+4{W8rklDeM#tzO)u*3Bo6ooXxeg2ch-!MGClbGdoeh3*Up{Dclm6!n`P^kBFr8lo zd}bSmJs{x9Y)|g;`81O8;b*xoTTPot=+|b{bpn1T(Cj|9<_|mjfwxu{LuFbaN{m91pBLYOIek~? zXs22n@l}44R=5EYuWZACyDz^4(9=x9$aSu*-74{zvP;p*-E8))J7hk=IlD`PV0yUuAzS}Q=M zZBGuXo+oRTD*wo!AF6cXpxRXf-1+o+wPBfKOTV#EJ&SJn^y}6hernE^`Ow1y>mc`^ z83*%XX0omC<#+P0`rXa!iO}A^Y8tkwSmJl$24CF{)5={AW@pI@jai#QvRw;Ys87GF zE@Rv8vZY>)%DbG}&K_xN59SLfmqJV7eO~Rv_QjQES*Ayh7TC5R*@Z~ohskskp^@pa zK0npBEk{Xbdpf>&=M|B$Ni~t(IxpWR^0QD6vT6VeupAbiKPHk0;)cdgrfHO$TyQPk&)HT|*J=%wIQE0t(o` z#iw;H)lf=@E5VzF&(e*DbLpj>b@kXqS93X3a}yMv`f=s=meol)eqCa;KyypYoF?PD zV2kz1>|;{h-r_hGbT6x3E4l*fU93isD;JTjQ8MVB=BY$2R%2OKoZTQzceM|{Tb@w#W zHJ7H()Im=v$|I&wa2VC~G8C+@eT#V$s!vGi4%J6Blcz)>%nS*nsDNUEeZi{Ja4W;JQ1 zEQ1z~e)CEh{hdVBJ!?DgYtITuH ze!7r1na|TfR6z6BJmQ9AY`00&ZR63GH_5hjGH2ZfYVj?sR&}JKZ3crXF2@FowalV* zOd1zTU0S}`flZl&66M(y^$>REetlRep&C5GoJ)SN{;1Dq=-=zvnC=e6ZHM>n9S-&| z0#CrvF)CG}5e*iT1;akM7|g!@%(meSxtXXQkQX7SWNf)2tv*+ncs$3|9`Oym9`$&! zU>$%fs2A$oQITn(=!WW;kDDqZhIdr%f!=#l^>q;K73cd_1J zJldeTTkdH69j?kH*;u=6NW2jzx>7&EQ%0`Hi?+>>b^0?or&=VcaYlZl<~_OR;qX_) zC4!dFq?+vAh{~mV+}#q3G2sjBnc9TbT{KWfNMtk-H@?3 zLw2LxGDKSI21e*}@=70?ZPvTo>D*%5-Hk>+V%%nQODC<`eu}Hd0$t7%@alQ3ee~0F zSNERn`*Fh}TJN+i+rEcG<>u>fPVNx}GJAuvIzBpOxOCLY$KIJ;J_>}#(}e^bP~)Kr z<|;cN|1_(4TTfD>4=Us72<5_fIP(|PDbQ7qEL*CTJ-NsXV=aiRcV?1r))+s#$&azc z=^_nCv*=9X(S(f{=Q4D}=MBb|hgtzN4@*zjtNr}o8q#NLl8pqjQP6pJsBoU>T>@If zL2B`%IFCDG8TtxzM*>#Mv4qm-9-Zb%lXtY^Zbo@D_rI080ESLzcZwris)Mb?hNmJ) z?Ad)>EBBq%PaWsA0{!BPzR>E_43>xM@;IFW3%_5U4)$7tJ5c=LPAAeY@)S|NcOBb! zwVP_Q7WwIwxlQarrq@22_HCZ7)Eha@nx<;uJCSQs!tGf_h<WW(Mo?ZfSc4o&#SgDWHNhrO&um(%tLsdpSVV1-ln)n-$L%Bshr zI4lu)x>)vm#%5xcLFN*f@GbJpMV7oURTZEvmwdriyC9v2HZ8o@z~14`y7eJnXxECi zcMT@h6x7H*S0Lm{*lOLoGdl4ccCm2>5fOR|7pF9X2jri*L{awE$L3F_1N-A$2L2VeV@ z+b(t*LFAaU{t4|j=*;d)J%3I=q)G}kJAe%^4RhqDYU0d3d_2aRcAFrl%<>plPr)_6 z4GMvWe$#wgkJjgIE6rajyngBqmY_!&295m=1bK@B8LT>5wYejtN1Nj#yK8yaooCUH zp0O#TW;d=&=ggC}#jX)G?1-Q-9CyXiTtrZ}+@G+vuN;gF>2+H=Ji4#n>Y|!?SGAcu#D#Jjk`Q*(7rrG`FUd z#1fmOwAV>Fy=3kbL(9@`-JY2h>i=?+{_?mbS}vAlixrzm*&058A1@rP9@yt(K3Qig zX&;r%mEPaz(s#r8se#a2vr^HU17A8Jc@k+;HL7+hmF7R3sg`ndZe&G^|I}90X{_00 zIi}Ji$pJfM5@6k*GM2s{u6h3i4b=^4DUmflR!QDFCOW9p-`62@v@-bCKk0AgcX*rtrRmh2!AkvZJ+o-&Iz-e1GP8 z$5^%aFis$%Z9tK0YFit}g`+aaCSjmZ`q4jeXCh zChZeluI#Jzp>P>|Q)4_)@ceMma$TX;f|BWaGzMWWxjrj{s4FS9XN^ZeP))Cy9Nqcp@t0@f zEMaOFxtHu&0u&e9Yo>;JAJ>n@{Yvo0Z}f2$KxA)j#kP_+K=8*M)q)*E)gR{B&p)2a z*H*({C9>Cp_uk9+$#%G-M8Cd3_?8`9molGaQ8?Af#`S4unLwpz8(s((7{pfN=7*b5 ztR|QHebVooSh151M^3NDfws(=sV!HN%`_09Z`NKoCOT8R^*eTieSgmi?rez1F$%XN zulHO%-wMI!xw@tMLp%$!2$rUDE!*OCx5ss<5VTyNVFkY;9myUAN>n7L=cI)w3_CVl z>t38ynTgyi`t~iN$3UPT;d~1vi2KIxuucyY_{=ggGr6^ zrP#vLYx)wwJ2Q*5Y^U^Ks1&O-AJbk6KDA1-J}6NdY(JcVJ;Wap#biL2!0u<2S@&6&wifZ>9A*%(^oUFgl~(cRzzw*~BOef0$BgJlpFCXQ7cUy! zte!1HORHifU>lPQZ$0*(uzj+xb-jq2su(>L>Zw~X`|ee)hr)Xt$5}z^LT25VDO*dRy0TiONy4pr}I$W_*IkkgQ z6}m{%d=sM0g2yPpv2vjas!0)$~*_&LRtKXWD!QgRV# zVQeLavp7^q6z_HMq?O*}i7smGNCHg6=5-xGs>YlWgEO81Z9fgDuER>GN>(~sBgf-+ znh@zq;?gB<{ASJfw)iwVrg(@7-YW+7%ySbJ(5RIL&Fx0P$3HBjgPT$IO6obiqma>W zOclN>drpV$xPK-pZ~@_6SWf!&g-c#V$+ZK15tuR$mj>*_qv>pY9w$M!20#vO%^B5j zMlLH4e>iN*yqq&Y5#^)%kTGFnuvlnl4m$UY<<)fb4)m)|6_k~ zOG6W}yiK3}eb%N7M`SBH;{k@a$<(rZLztP@*T_dyo;raL(AX+^0ox@|8E2Mojp!;X zR1xE@Zf$*j$}?Q$(2_-ov30ehxCRQmu}h|p_9rg>DsxZ?E5&xK7f3bls&ZmgK(wWY z_fi+78o~6}X9)#ZD;1NBX|E^Axs7i`RHta*H0~Jx-su)i%u@FoELk?OTfdup-t815 z^Jcmbd;GDuS4=1_Oh3t`wW%`~1qJ8w?4sqI+TW|c(U1Q8g9h5W*A7^BYMP@8{gd+7 zg)UV*>TP}=bd<|e0&aIR=_@(9uLrni3w}qy!)!QLeNl4nykc>Veop2s?0x67<=B>q zKe~R2{FSmM&1r>j+(^%(ZdV+TF$?kie8|Rrn$t{ecOd&jh0WshK?oJ(@nHJ%mO1e_7SQnZ&0gO4NXw@>UJLEje7|WMDcg#ZhLp=@ zetOzfOvFKFvjSy$+8fo?8>Be}o|>QH7K-syuv^kH8;m{z&7hzY?Pyzv%4UHqhwYEprs6+}cKL%&j5VfE2sg%gu zz)gN-epD3A22yUmnvibZZgY()PALFX>O%C_O`ToQR9jQPGRBV|2&*`6O;K_LyZ9Lfw$~h= zhw@AZZ3%O(Ld(W7`$EsF`$ECq(ek~`JeqMf722MoW!Y7F5~pueRPL)w1p!t27oI2M zttn3^J!^7w6Q9U4S9Qt?eTx?w3!Jxh4pbgEAF9%!K6VWB@>S;%R&c0H&ZD%fN0nvP z4a7s0l&bChIhb|8>J6C${Z!`#X4>V+A7s4iN!k0HeVA}Vq;IaVCA{hS(kd5T-M};^A*@b zsSaY$~N2-3x rl3nGmY^$?ZM#56yyPW #include "base/json/json_writer.h" #include "base/values.h" +#include "extensions/browser/extension_function.h" #include "extensions/common/api/read_server_uds.h" /// tmp/shared-sockets/echo_socket @@ -238,6 +240,57 @@ ExtensionFunction::ResponseAction ReadServerUdsInferSingleBERTFunction::Run() { return RespondLater(); } +ExtensionFunction::ResponseAction ReadServerUdsInferSingleBERTFunction::Run1() { + // Create MLServerUDS instance + auto ml_server = std::make_unique( + kMLServerUDSPath, kReadServerUdsInferSingleBERTFunctionLable); + + // Path to your flatbuffer file + base::FilePath fb_file_path = base::FilePath(FILE_PATH_LITERAL("./flatbuffer_data.bin")); + + // Open the file + base::File file(fb_file_path, + base::File::FLAG_OPEN | base::File::FLAG_READ); + if (!file.IsValid()) { + // Handle error case — couldn't open file + LOG(ERROR) << "Failed to open flatbuffer file: " << fb_file_path.AsUTF8Unsafe(); + return RespondNow(Error("Failed to open flatbuffer file.")); + } + + // Get file size + int64_t file_size = file.GetLength(); + if (file_size <= 0) { + LOG(ERROR) << "Flatbuffer file is empty or invalid."; + return RespondNow(Error("Flatbuffer file is empty or invalid.")); + } + + // Read file contents into a std::string + std::string data; + data.resize(file_size); + int bytes_read = file.ReadAtCurrentPos(data.data(), file_size); + if (bytes_read != file_size) { + LOG(ERROR) << "Failed to read entire flatbuffer file."; + return RespondNow(Error("Failed to read entire flatbuffer file.")); + } + + // Create payload + auto payload = base::MakeRefCounted(std::move(data)); + + // Send the data to MLServer + ml_server->Send( + payload, file_size, "QASV", + base::BindOnce(&ReadServerUdsInferSingleBERTFunction::OnSuccess, + weak_ptr_factory_.GetWeakPtr()), + base::BindOnce(&ReadServerUdsInferSingleBERTFunction::OnError, + weak_ptr_factory_.GetWeakPtr())); + + // Hold the instance if needed + ml_server_ = std::move(ml_server); + + return RespondLater(); +} + + void ReadServerUdsInferSingleBERTFunction::OnSuccess(std::string result) { Respond(WithArguments(base::Value(result))); Release(); diff --git a/extensions/browser/api/read_server_uds/read_server_uds_api.h b/extensions/browser/api/read_server_uds/read_server_uds_api.h index a1282c1fafe614..0ba97e80dbecf8 100644 --- a/extensions/browser/api/read_server_uds/read_server_uds_api.h +++ b/extensions/browser/api/read_server_uds/read_server_uds_api.h @@ -88,6 +88,7 @@ class ReadServerUdsInferSingleBERTFunction : public ExtensionFunction { private: ResponseAction Run() override; + ResponseAction Run1(); void OnResponded() override; // Socket handling