jtcsv 2.2.7 → 3.0.0

package/src/workers/csv-multithreaded.ts

@@ -0,0 +1,310 @@
+/**
+ * Многопоточная обработка CSV данных
+ * 
+ * Интеграция Worker Pool с существующими асинхронными функциями
+ */
+
+import { getWorkerPool, createWorkerTask } from './worker-pool';
+import { CsvToJsonOptions, AsyncCsvToJsonOptions, AnyArray, AnyObject } from '../types';
+import { chunkData, createChunkTasks, mergeChunkResults } from './csv-parser.worker';
+
+/**
+ * Многопоточная версия csvToJson
+ * 
+ * @param csv - CSV строка для парсинга
+ * @param options - Опции с поддержкой многопоточности
+ * @returns Promise с результатом парсинга
+ */
+export async function csvToJsonMultithreaded(
+  csv: string,
+  options: AsyncCsvToJsonOptions = {}
+): Promise<AnyArray> {
+  const {
+    useWorkers = true,
+    workerCount,
+    chunkSize = 1000,
+    onProgress,
+    ...csvOptions
+  } = options;
+  
+  // Если многопоточность отключена или данные маленькие, используем обычную версию
+  if (!useWorkers || csv.length < 10000) {
+    const { csvToJson } = await import('../../csv-to-json');
+    return csvToJson(csv, csvOptions);
+  }
+  
+  // Разделяем CSV на строки
+  const lines = csv.split('\n').filter(line => line.trim() !== '');
+  
+  if (lines.length === 0) {
+    return [];
+  }
+  
+  // Определяем есть ли заголовки
+  const hasHeaders = csvOptions.hasHeaders !== false;
+  
+  // Разделяем данные на чанки
+  let dataChunks: string[][];
+  let headers: string[] = [];
+  
+  if (hasHeaders) {
+    headers = lines[0].split(csvOptions.delimiter || ';');
+    const dataLines = lines.slice(1);
+    dataChunks = chunkData(dataLines, chunkSize);
+  } else {
+    dataChunks = chunkData(lines, chunkSize);
+  }
+  
+  // Создаем задачи для воркеров
+  const tasks = dataChunks.map((chunk, index) => {
+    // Восстанавливаем CSV чанк с заголовками если нужно
+    let chunkCsv = chunk.join('\n');
+    if (hasHeaders && headers.length > 0) {
+      chunkCsv = headers.join(csvOptions.delimiter || ';') + '\n' + chunkCsv;
+    }
+    
+    return createWorkerTask('csv_parse', chunkCsv, {
+      ...csvOptions,
+      chunkIndex: index,
+      totalChunks: dataChunks.length,
+      hasHeaders: index === 0 ? hasHeaders : false // Только первый чанк получает заголовки
+    });
+  });
+  
+  // Получаем пул воркеров
+  const workerPool = getWorkerPool(workerCount);
+  
+  // Отправляем прогресс если есть callback
+  if (onProgress) {
+    workerPool.on('taskCompleted', ({ task }) => {
+      const chunkIndex = task.options?.chunkIndex || 0;
+      const totalChunks = task.options?.totalChunks || 1;
+      
+      onProgress({
+        processed: chunkIndex + 1,
+        total: totalChunks,
+        percentage: Math.round(((chunkIndex + 1) / totalChunks) * 100)
+      });
+    });
+  }
+  
+  // Выполняем задачи параллельно
+  const results = await workerPool.executeTasks(tasks);
+  
+  // Объединяем результаты
+  const mergedResults = mergeChunkResults(results);
+  
+  return mergedResults;
+}
+
+/**
+ * Многопоточная версия jsonToCsv
+ * 
+ * @param data - JSON данные для конвертации
+ * @param options - Опции с поддержкой многопоточности
+ * @returns Promise с CSV строкой
+ */
+export async function jsonToCsvMultithreaded(
+  data: AnyArray | AnyObject,
+  options: any = {} // TODO: Добавить тип AsyncJsonToCsvOptions
+): Promise<string> {
+  const {
+    useWorkers = true,
+    workerCount,
+    chunkSize = 1000,
+    onProgress,
+    ...jsonOptions
+  } = options;
+  
+  // Подготавливаем данные
+  const dataArray = Array.isArray(data) ? data : [data];
+  
+  // Если многопоточность отключена или данные маленькие, используем обычную версию
+  if (!useWorkers || dataArray.length < 1000) {
+    const { jsonToCsv } = await import('../../json-to-csv');
+    return jsonToCsv(dataArray, jsonOptions);
+  }
+  
+  // Разделяем данные на чанки
+  const dataChunks = chunkData(dataArray, chunkSize);
+  
+  // Создаем задачи для воркеров
+  const tasks = dataChunks.map((chunk, index) => {
+    return createWorkerTask('json_to_csv', chunk, {
+      ...jsonOptions,
+      chunkIndex: index,
+      totalChunks: dataChunks.length,
+      includeHeaders: index === 0 // Только первый чанк включает заголовки
+    });
+  });
+  
+  // Получаем пул воркеров
+  const workerPool = getWorkerPool(workerCount);
+  
+  // Отправляем прогресс если есть callback
+  if (onProgress) {
+    workerPool.on('taskCompleted', ({ task }) => {
+      const chunkIndex = task.options?.chunkIndex || 0;
+      const totalChunks = task.options?.totalChunks || 1;
+      
+      onProgress({
+        processed: chunkIndex + 1,
+        total: totalChunks,
+        percentage: Math.round(((chunkIndex + 1) / totalChunks) * 100)
+      });
+    });
+  }
+  
+  // Выполняем задачи параллельно
+  const results = await workerPool.executeTasks(tasks);
+  
+  // Объединяем CSV чанки
+  let finalCsv = '';
+  
+  for (let i = 0; i < results.length; i++) {
+    const chunkCsv = results[i];
+    
+    if (i === 0) {
+      // Первый чанк включает заголовки
+      finalCsv = chunkCsv;
+    } else {
+      // Последующие чанки - только данные (убираем первую строку если это заголовки)
+      const lines = chunkCsv.split('\n');
+      if (lines.length > 1 && jsonOptions.includeHeaders !== false) {
+        finalCsv += '\n' + lines.slice(1).join('\n');
+      } else {
+        finalCsv += '\n' + chunkCsv;
+      }
+    }
+  }
+  
+  return finalCsv;
+}
+
+/**
+ * Бенчмарк многопоточной обработки
+ * 
+ * @param data - Данные для тестирования
+ * @param iterations - Количество итераций
+ * @returns Результаты бенчмарка
+ */
+export async function benchmarkMultithreaded(
+  data: AnyArray | string,
+  iterations: number = 10
+): Promise<{
+  singleThread: number;
+  multiThread: number;
+  speedup: number;
+  efficiency: number;
+}> {
+  const workerPool = getWorkerPool();
+  const cpuCount = require('os').cpus().length;
+  
+  // Тестируем однопоточную обработку
+  const singleThreadStart = Date.now();
+  
+  if (typeof data === 'string') {
+    // CSV парсинг
+    const { csvToJson } = await import('../../csv-to-json');
+    for (let i = 0; i < iterations; i++) {
+      await csvToJson(data);
+    }
+  } else {
+    // JSON to CSV
+    const { jsonToCsv } = await import('../../json-to-csv');
+    for (let i = 0; i < iterations; i++) {
+      await jsonToCsv(data);
+    }
+  }
+  
+  const singleThreadTime = Date.now() - singleThreadStart;
+  
+  // Тестируем многопоточную обработку
+  const multiThreadStart = Date.now();
+  
+  if (typeof data === 'string') {
+    for (let i = 0; i < iterations; i++) {
+      await csvToJsonMultithreaded(data, {
+        useWorkers: true,
+        workerCount: cpuCount - 1
+      });
+    }
+  } else {
+    for (let i = 0; i < iterations; i++) {
+      await jsonToCsvMultithreaded(data, {
+        useWorkers: true,
+        workerCount: cpuCount - 1
+      });
+    }
+  }
+  
+  const multiThreadTime = Date.now() - multiThreadStart;
+  
+  // Вычисляем ускорение и эффективность
+  const speedup = singleThreadTime / multiThreadTime;
+  const efficiency = (speedup / (cpuCount - 1)) * 100;
+  
+  return {
+    singleThread: singleThreadTime,
+    multiThread: multiThreadTime,
+    speedup,
+    efficiency
+  };
+}
+
+/**
+ * Оптимизирует размер чанка на основе размера данных
+ * 
+ * @param dataSize - Размер данных (количество строк или байт)
+ * @param workerCount - Количество воркеров
+ * @returns Оптимальный размер чанка
+ */
+export function optimizeChunkSize(
+  dataSize: number,
+  workerCount: number = Math.max(1, require('os').cpus().length - 1)
+): number {
+  // Базовый размер чанка
+  let chunkSize = 1000;
+  
+  if (dataSize > 1000000) {
+    // Очень большие данные - увеличиваем размер чанка
+    chunkSize = 10000;
+  } else if (dataSize > 100000) {
+    // Большие данные
+    chunkSize = 5000;
+  } else if (dataSize > 10000) {
+    // Средние данные
+    chunkSize = 2000;
+  } else if (dataSize < 1000) {
+    // Маленькие данные - уменьшаем размер чанка
+    chunkSize = Math.max(100, Math.ceil(dataSize / workerCount));
+  }
+  
+  // Учитываем количество воркеров
+  chunkSize = Math.max(chunkSize, Math.ceil(dataSize / (workerCount * 10)));
+  
+  return chunkSize;
+}
+
+/**
+ * Мониторинг использования ресурсов
+ * 
+ * @returns Статистика использования ресурсов
+ */
+export function getResourceUsage(): {
+  cpuUsage: NodeJS.CpuUsage;
+  memoryUsage: NodeJS.MemoryUsage;
+  workerStats: any;
+} {
+  const cpuUsage = process.cpuUsage();
+  const memoryUsage = process.memoryUsage();
+  
+  const workerPool = getWorkerPool();
+  const workerStats = workerPool.getStats();
+  
+  return {
+    cpuUsage,
+    memoryUsage,
+    workerStats
+  };
+}

package/src/workers/csv-parser.worker.ts

@@ -0,0 +1,227 @@
+/**
+ * Worker для парсинга CSV данных
+ * 
+ * Выполняется в отдельном потоке для многопоточной обработки
+ */
+
+import { parentPort, workerData, isMainThread } from 'worker_threads';
+import { WorkerTask, WorkerResult } from '../types';
+
+// Импортируем функции парсинга из основных модулей
+// Используем динамический импорт чтобы избежать циклических зависимостей
+let csvToJson: any = null;
+let jsonToCsv: any = null;
+
+/**
+ * Инициализирует функции парсинга
+ */
+async function initializeParserFunctions(): Promise<void> {
+  if (!csvToJson) {
+    // Динамический импорт чтобы избежать проблем с циклическими зависимостями
+    const csvModule = await import('../../csv-to-json');
+    csvToJson = csvModule.csvToJson;
+  }
+  
+  if (!jsonToCsv) {
+    const jsonModule = await import('../../json-to-csv');
+    jsonToCsv = jsonModule.jsonToCsv;
+  }
+}
+
+/**
+ * Обрабатывает задачу парсинга CSV
+ */
+async function processCsvParsing(task: WorkerTask): Promise<any> {
+  await initializeParserFunctions();
+  
+  const { data, options } = task;
+  
+  if (typeof data !== 'string') {
+    throw new Error('CSV data must be a string');
+  }
+  
+  return csvToJson(data, options);
+}
+
+/**
+ * Обрабатывает задачу конвертации JSON в CSV
+ */
+async function processJsonToCsv(task: WorkerTask): Promise<any> {
+  await initializeParserFunctions();
+  
+  const { data, options } = task;
+  
+  if (!Array.isArray(data) && (typeof data !== 'object' || data === null)) {
+    throw new Error('JSON data must be an array or object');
+  }
+  
+  return jsonToCsv(data, options);
+}
+
+/**
+ * Обрабатывает задачу обработки чанка данных
+ */
+async function processDataChunk(task: WorkerTask): Promise<any> {
+  const { type, data, options } = task;
+  
+  switch (type) {
+    case 'csv_parse':
+      return processCsvParsing(task);
+      
+    case 'json_to_csv':
+      return processJsonToCsv(task);
+      
+    case 'transform_data':
+      // Простая трансформация данных
+      if (Array.isArray(data)) {
+        return data.map((item, index) => ({
+          ...item,
+          _workerId: workerData?.workerId || 0,
+          _chunkIndex: index
+        }));
+      }
+      return data;
+      
+    case 'validate_data':
+      // Валидация данных
+      if (Array.isArray(data)) {
+        const invalidItems = data.filter(item => 
+          item === null || item === undefined || 
+          (typeof item === 'object' && Object.keys(item).length === 0)
+        );
+        
+        return {
+          valid: invalidItems.length === 0,
+          totalItems: data.length,
+          invalidItems: invalidItems.length,
+          invalidIndexes: data
+            .map((item, index) => ({ item, index }))
+            .filter(({ item }) => 
+              item === null || item === undefined || 
+              (typeof item === 'object' && Object.keys(item).length === 0)
+            )
+            .map(({ index }) => index)
+        };
+      }
+      return { valid: true, totalItems: 1 };
+      
+    default:
+      throw new Error(`Unknown task type: ${type}`);
+  }
+}
+
+/**
+ * Основная функция воркера
+ */
+async function main() {
+  if (isMainThread) {
+    console.error('Worker script should not be run in main thread');
+    process.exit(1);
+  }
+  
+  // Регистрируем обработчик сообщений
+  parentPort?.on('message', async (task: WorkerTask) => {
+    const startTime = Date.now();
+    
+    try {
+      const result = await processDataChunk(task);
+      const duration = Date.now() - startTime;
+      
+      const workerResult: WorkerResult = {
+        id: task.id,
+        result,
+        duration
+      };
+      
+      parentPort?.postMessage(workerResult);
+    } catch (error: any) {
+      const duration = Date.now() - startTime;
+      
+      const workerResult: WorkerResult = {
+        id: task.id,
+        result: null,
+        error: error instanceof Error ? error : new Error(String(error)),
+        duration
+      };
+      
+      parentPort?.postMessage(workerResult);
+    }
+  });
+  
+  // Отправляем сообщение о готовности
+  parentPort?.postMessage({
+    type: 'worker_ready',
+    workerId: workerData?.workerId || 0,
+    pid: process.pid
+  });
+  
+  // Обрабатываем сигналы завершения
+  process.on('SIGTERM', () => {
+    parentPort?.postMessage({
+      type: 'worker_shutdown',
+      workerId: workerData?.workerId || 0
+    });
+    process.exit(0);
+  });
+  
+  process.on('SIGINT', () => {
+    parentPort?.postMessage({
+      type: 'worker_shutdown',
+      workerId: workerData?.workerId || 0
+    });
+    process.exit(0);
+  });
+}
+
+// Запускаем воркер
+main().catch(error => {
+  console.error('Worker initialization failed:', error);
+  process.exit(1);
+});
+
+/**
+ * Утилитарные функции для воркера
+ */
+
+/**
+ * Разделяет данные на чанки для параллельной обработки
+ */
+export function chunkData<T>(data: T[], chunkSize: number): T[][] {
+  const chunks: T[][] = [];
+  
+  for (let i = 0; i < data.length; i += chunkSize) {
+    chunks.push(data.slice(i, i + chunkSize));
+  }
+  
+  return chunks;
+}
+
+/**
+ * Объединяет результаты обработки чанков
+ */
+export function mergeChunkResults<T>(chunkResults: T[][]): T[] {
+  return chunkResults.flat();
+}
+
+/**
+ * Создает задачи для обработки чанков
+ */
+export function createChunkTasks<T, R>(
+  data: T[],
+  chunkSize: number,
+  taskType: string,
+  options?: Record<string, any>
+): WorkerTask<T[], R>[] {
+  const chunks = chunkData(data, chunkSize);
+  
+  return chunks.map((chunk, index) => ({
+    id: `chunk_${index}_${Date.now()}`,
+    type: taskType,
+    data: chunk,
+    options: {
+      ...options,
+      chunkIndex: index,
+      totalChunks: chunks.length
+    }
+  }));
+}