পারফরমেন্স অপ্টিমাইজেশন উদাহরণ

এখানে Sharp পারফরমেন্স অপ্টিমাইজেশনের কিছু উদাহরণ এবং সেরা অনুশীলন দেওয়া হয়েছে।

মেমরি অপ্টিমাইজেশন

বড় ফাইলের জন্য স্ট্রিম প্রসেসিং

import sharp from 'sharp';
import fs from 'fs';

// স্ট্রিম প্রসেসিং, পুরো ফাইল মেমরিতে লোড করা এড়ান
fs.createReadStream('large-image.jpg')
  .pipe(sharp().resize(800, 600))
  .pipe(fs.createWriteStream('output.jpg'));

ফাইলের পরিবর্তে Buffer ব্যবহার করুন

// ছোট ফাইলের জন্য, Buffer ব্যবহার করা আরও দক্ষ
const inputBuffer = fs.readFileSync('input.jpg');
const outputBuffer = await sharp(inputBuffer)
  .resize(300, 200)
  .jpeg({ quality: 80 })
  .toBuffer();

fs.writeFileSync('output.jpg', outputBuffer);

সময়মতো রিসোর্স মুক্ত করুন

// প্রসেসিং সম্পন্ন হলে সময়মতো মুক্ত করুন
const image = sharp('input.jpg');
await image.resize(300, 200).toFile('output.jpg');
// image ইনস্ট্যান্স স্বয়ংক্রিয়ভাবে গার্বেজ কালেকশন হবে

কনকারেন্সি কন্ট্রোল

কনকারেন্সি সংখ্যা সীমাবদ্ধ করুন

// সর্বোচ্চ কনকারেন্সি সংখ্যা সেট করুন
sharp.concurrency(4);

// ব্যাচ প্রসেসিংয়ের সময় কনকারেন্সি নিয়ন্ত্রণ করুন
async function batchProcess(files) {
  const batchSize = 4;
  const results = [];
  
  for (let i = 0; i < files.length; i += batchSize) {
    const batch = files.slice(i, i + batchSize);
    const batchPromises = batch.map(file => 
      sharp(file).resize(300, 200).jpeg().toFile(`output_${file}`)
    );
    
    await Promise.all(batchPromises);
    results.push(...batch);
  }
  
  return results;
}

কিউ প্রসেসিং ব্যবহার করুন

class ImageProcessor {
  constructor(concurrency = 4) {
    this.concurrency = concurrency;
    this.queue = [];
    this.running = 0;
  }
  
  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.process();
    });
  }
  
  async process() {
    if (this.running >= this.concurrency || this.queue.length === 0) {
      return;
    }
    
    this.running++;
    const { task, resolve, reject } = this.queue.shift();
    
    try {
      const result = await task();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.running--;
      this.process();
    }
  }
}

// ব্যবহারের উদাহরণ
const processor = new ImageProcessor(4);

for (const file of files) {
  processor.add(async () => {
    await sharp(file).resize(300, 200).jpeg().toFile(`output_${file}`);
  });
}

ক্যাশে অপ্টিমাইজেশন

প্রসেসিং ফলাফল ক্যাশে করুন

const cache = new Map();

async function processWithCache(inputPath, width, height) {
  const key = `${inputPath}_${width}_${height}`;
  
  if (cache.has(key)) {
    return cache.get(key);
  }
  
  const result = await sharp(inputPath)
    .resize(width, height)
    .jpeg({ quality: 80 })
    .toBuffer();
  
  cache.set(key, result);
  return result;
}

Sharp ক্যাশে সাফ করুন

// মেমরি মুক্ত করার জন্য নিয়মিত ক্যাশে সাফ করুন
setInterval(() => {
  sharp.cache(false);
}, 60000); // প্রতি মিনিটে একবার সাফ করুন

অ্যালগরিদম নির্বাচন

উপযুক্ত রিসাইজ অ্যালগরিদম নির্বাচন করুন

// ছোট করার জন্য দ্রুত অ্যালগরিদম ব্যবহার করুন
await sharp('input.jpg')
  .resize(300, 200, { kernel: sharp.kernel.cubic })
  .toFile('output.jpg');

// বড় করার জন্য উচ্চ-কোয়ালিটি অ্যালগরিদম ব্যবহার করুন
await sharp('input.jpg')
  .resize(1200, 800, { kernel: sharp.kernel.lanczos3 })
  .toFile('output.jpg');

ব্যাচ প্রসেসিং অপ্টিমাইজেশন

async function optimizedBatchProcess(files) {
  // আকার অনুযায়ী গ্রুপ করে প্রসেস করুন
  const smallFiles = [];
  const largeFiles = [];
  
  for (const file of files) {
    const metadata = await sharp(file).metadata();
    if (metadata.width * metadata.height < 1000000) {
      smallFiles.push(file);
    } else {
      largeFiles.push(file);
    }
  }
  
  // ছোট ফাইলের জন্য দ্রুত অ্যালগরিদম ব্যবহার করুন
  await Promise.all(smallFiles.map(file =>
    sharp(file)
      .resize(300, 200, { kernel: sharp.kernel.cubic })
      .jpeg({ quality: 80 })
      .toFile(`output_${file}`)
  ));
  
  // বড় ফাইলের জন্য উচ্চ-কোয়ালিটি অ্যালগরিদম ব্যবহার করুন
  await Promise.all(largeFiles.map(file =>
    sharp(file)
      .resize(800, 600, { kernel: sharp.kernel.lanczos3 })
      .jpeg({ quality: 90 })
      .toFile(`output_${file}`)
  ));
}

নেটওয়ার্ক অপ্টিমাইজেশন

স্ট্রিম রেসপন্স

// Express.js উদাহরণ
app.get('/image/:filename', async (req, res) => {
  const filename = req.params.filename;
  
  try {
    const imageStream = sharp(`images/${filename}`)
      .resize(300, 200)
      .jpeg({ quality: 80 });
    
    res.set('Content-Type', 'image/jpeg');
    imageStream.pipe(res);
  } catch (error) {
    res.status(404).send('Image not found');
  }
});

শর্তাধীন প্রসেসিং

app.get('/image/:filename', async (req, res) => {
  const { filename } = req.params;
  const { width, height, quality = 80 } = req.query;
  
  try {
    let image = sharp(`images/${filename}`);
    
    if (width || height) {
      image = image.resize(parseInt(width), parseInt(height));
    }
    
    if (req.headers.accept?.includes('image/webp')) {
      image = image.webp({ quality: parseInt(quality) });
      res.set('Content-Type', 'image/webp');
    } else {
      image = image.jpeg({ quality: parseInt(quality) });
      res.set('Content-Type', 'image/jpeg');
    }
    
    image.pipe(res);
  } catch (error) {
    res.status(404).send('Image not found');
  }
});

মনিটরিং এবং ডিবাগিং

পারফরমেন্স মনিটরিং

async function processWithTiming(inputPath, outputPath) {
  const startTime = Date.now();
  
  try {
    await sharp(inputPath)
      .resize(800, 600)
      .jpeg({ quality: 80 })
      .toFile(outputPath);
    
    const endTime = Date.now();
    console.log(`প্রসেসিং সময়: ${endTime - startTime}ms`);
  } catch (error) {
    console.error('প্রসেসিং ব্যর্থ:', error.message);
  }
}

মেমরি ব্যবহার মনিটরিং

const process = require('process');

function logMemoryUsage() {
  const usage = process.memoryUsage();
  console.log('মেমরি ব্যবহার:', {
    rss: `${Math.round(usage.rss / 1024 / 1024)} MB`,
    heapTotal: `${Math.round(usage.heapTotal / 1024 / 1024)} MB`,
    heapUsed: `${Math.round(usage.heapUsed / 1024 / 1024)} MB`,
    external: `${Math.round(usage.external / 1024 / 1024)} MB`
  });
}

// প্রসেসিংয়ের আগে এবং পরে মেমরি ব্যবহার রেকর্ড করুন
logMemoryUsage();
await sharp('input.jpg').resize(800, 600).toFile('output.jpg');
logMemoryUsage();

এরর হ্যান্ডলিং এবং রিট্রাই

রিট্রাই মেকানিজম

async function processWithRetry(inputPath, outputPath, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      await sharp(inputPath)
        .resize(800, 600)
        .jpeg({ quality: 80 })
        .toFile(outputPath);
      
      console.log(`প্রসেসিং সফল, প্রচেষ্টা সংখ্যা: ${attempt}`);
      return;
    } catch (error) {
      console.error(`প্রচেষ্টা ${attempt} ব্যর্থ:`, error.message);
      
      if (attempt === maxRetries) {
        throw new Error(`প্রসেসিং ব্যর্থ, ${maxRetries} বার পুনরায় চেষ্টা করা হয়েছে`);
      }
      
      // কিছুক্ষণ অপেক্ষা করে পুনরায় চেষ্টা করুন
      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
    }
  }
}

এরর শ্রেণীবিভাগ হ্যান্ডলিং

async function robustProcess(inputPath, outputPath) {
  try {
    await sharp(inputPath)
      .resize(800, 600)
      .jpeg({ quality: 80 })
      .toFile(outputPath);
  } catch (error) {
    if (error.code === 'VipsForeignLoad') {
      console.error('অসমর্থিত ইমেজ ফরম্যাট');
    } else if (error.code === 'VipsForeignLoadLimit') {
      console.error('ইমেজ খুব বড়, ছোট করার চেষ্টা করুন');
      // ছোট ভার্সন প্রসেস করার চেষ্টা করুন
      await sharp(inputPath, { limitInputPixels: 268402689 })
        .resize(400, 300)
        .jpeg({ quality: 80 })
        .toFile(outputPath);
    } else if (error.code === 'ENOSPC') {
      console.error('ডিস্ক স্পেস অপর্যাপ্ত');
    } else {
      console.error('অজানা এরর:', error.message);
    }
  }
}

সেরা অনুশীলন সারাংশ

1. উপযুক্ত প্রসেসিং পদ্ধতি নির্বাচন করুন

// ছোট ফাইল: সরাসরি প্রসেস করুন
if (fileSize < 1024 * 1024) {
  await sharp(file).resize(300, 200).toFile(output);
}

// বড় ফাইল: স্ট্রিম প্রসেসিং ব্যবহার করুন
else {
  fs.createReadStream(file)
    .pipe(sharp().resize(300, 200))
    .pipe(fs.createWriteStream(output));
}

2. ব্যাচ প্রসেসিং অপ্টিমাইজেশন

// কনকারেন্ট প্রসেসিংয়ের জন্য Promise.all ব্যবহার করুন
const promises = files.map(file => 
  sharp(file).resize(300, 200).jpeg().toFile(`output_${file}`)
);
await Promise.all(promises);

3. মেমরি ম্যানেজমেন্ট

// নিয়মিত ক্যাশে সাফ করুন
setInterval(() => {
  sharp.cache(false);
}, 300000); // প্রতি 5 মিনিটে একবার সাফ করুন

4. এরর হ্যান্ডলিং

// সবসময় try-catch ব্যবহার করুন
try {
  await sharp(input).resize(300, 200).toFile(output);
} catch (error) {
  console.error('প্রসেসিং ব্যর্থ:', error.message);
  // বিকল্প সমাধান প্রদান করুন
}

সম্পর্কিত লিঙ্ক

• মৌলিক উদাহরণ
• উন্নত উদাহরণ
• API রেফারেন্স
• ইনস্টলেশন গাইড