Serverless 환경에서 I/O 처리 최적화 경험기

"use server"
 async function readMDXFile(category: string, dir: string) {
    const files = await fs.readdir(dir);

    await Promise.all(
      files.map(async (filePath) => {
        const fullPath = path.join(dir, filePath);
        const stats = await fs.stat(fullPath);
        if (stats.isDirectory()) {
          this.readMDXFile(category, fullPath);
        } else {
          const fileData = await fs.readFile(fullPath, "utf-8");
          const parsedPostContent = matter(fileData);
          const frontMatter = FrontMatterSchema.safeParse(
            parsedPostContent.data,
          );
          ...
        }
    );
  }

Sequential readFile: 27.151s
Sequential readFile: 26.964s
Sequential readFile: 27.267s
Sequential readFile: 26.789s
Sequential readFile: 26.289s
Sequential readFile: 24.253s
Sequential readFile: 24.203s
Sequential readFile: 24.234s
Sequential readFile: 24.274s
Sequential readFile: 24.228s

Concurrent readFile with Promise.all: 13.577s
Concurrent readFile with Promise.all: 13.096s
Concurrent readFile with Promise.all: 13.469s
Concurrent readFile with Promise.all: 13.324s
Concurrent readFile with Promise.all: 12.651s
Concurrent readFile with Promise.all: 12.159s
Concurrent readFile with Promise.all: 12.633s
Concurrent readFile with Promise.all: 12.434s
Concurrent readFile with Promise.all: 12.221s
Concurrent readFile with Promise.all: 12.241s

10000개의 파일을 처리: 14.315s
10000개의 파일을 처리: 13.897s
10000개의 파일을 처리: 14.147s
10000개의 파일을 처리: 14.473s
10000개의 파일을 처리: 15.334s
10000개의 파일을 처리: 14.181s
10000개의 파일을 처리: 14.376s
10000개의 파일을 처리: 13.466s
10000개의 파일을 처리: 14.348s
10000개의 파일을 처리: 14.275s

Worker [50000 ~ 75000] 파일 읽기: 5.445s
Worker [0 ~ 25000] 파일 읽기: 5.943s
Worker [25000 ~ 50000] 파일 읽기: 6.062s
Worker [75000 ~ 100000] 파일 읽기: 6.469s
Worker 작업 수행 시간: 7.252s

Worker [0 ~ 25000] 파일 읽기: 4.534s
Worker [75000 ~ 100000] 파일 읽기: 5.525s
Worker [25000 ~ 50000] 파일 읽기: 6.184s
Worker [50000 ~ 75000] 파일 읽기: 6.418s
Worker 작업 수행 시간: 6.905s

Worker [0 ~ 100000] 파일 읽기: 15.976s
Worker 작업 수행 시간: 16.026s
Worker [0 ~ 100000] 파일 읽기: 15.837s
Worker 작업 수행 시간: 15.883s
Worker [0 ~ 100000] 파일 읽기: 16.350s
Worker 작업 수행 시간: 16.394s
Worker [0 ~ 100000] 파일 읽기: 17.016s
Worker 작업 수행 시간: 17.061s
Worker [0 ~ 100000] 파일 읽기: 16.807s
Worker 작업 수행 시간: 16.854s
Worker [0 ~ 100000] 파일 읽기: 17.226s
Worker 작업 수행 시간: 17.284s

Worker [50000 ~ 75000] 파일 읽기: 20.062s
Worker [25000 ~ 50000] 파일 읽기: 20.113s
Worker [75000 ~ 100000] 파일 읽기: 20.708s
Worker [0 ~ 25000] 파일 읽기: 20.806s
Worker 작업 수행 시간: 21.756s

#!/usr/bin/env bash

NUM_FILES=100000
TARGET_DIR="./longtext-files"
LONG_TEXT="longonglndinfdfkjds"

mkdir -p "$TARGET_DIR"
LONG_TEXT_REPEATED=$(yes "$LONG_TEXT" | head -n 1000 | tr -d '\n')

echo "총 $NUM_FILES 개의 파일을 생성합니다."
for ((i = 0; i < NUM_FILES; i++)); do
  echo "$LONG_TEXT_REPEATED" > "$TARGET_DIR/file-$i.txt"
  if ((i > 0 && i % 10000 == 0)); then
    echo "$i 개의 파일 생성 완료"
  fi
done

echo "모든 파일 생성 완료!"

LONG_TEXT_REPEATED=$(yes "$LONG_TEXT" | head -n 1000 | tr -d '\n')

A | B | C

echo "$LONG_TEXT_REPEATED" > "$TARGET_DIR/file-$i.txt"

async function processFile(fullPath: string, file: string) {
  if (!parentPort) return;
  try {
    let frontmatter: z.infer<typeof FrontMatterSchema> | null = null;
    const slug = file.split(".")[0];
    const readStream = createReadStream(fullPath, { encoding: "utf-8" });
    for await (const chunk of readStream) {
      if (!frontmatter && FRONTMATTER_REGEX.test(chunk)) {
        const { data, content } = matter(chunk);
        if (validateFrontMatter(data)) frontmatter = data;

        parentPort.postMessage({
          type: "data",
          slug,
          frontmatter,
          content,
        });
      } else {
        parentPort.postMessage({
          type: "data",
          slug,
          content: chunk,
        });
      }
    }
    parentPort.postMessage({
      type: "fileComplete",
      slug,
    });
  } catch (error) {
    parentPort.postMessage({
      type: "error",
      message: `${file} 파일을 읽는 중 오류가 발생했습니다.`,
    });
  }
}

import fs from "fs/promises";
import path from "path";

const fileName = "longtext-files";

(async () => {
  const dirPath = path.join(process.cwd(), fileName);
  const files = await fs.readdir(dirPath);
  console.time("Sequential readFile");
  for (const file of files) {
    await fs.readFile(path.join(dirPath, file));
  }
  console.timeEnd("Sequential readFile");
})();

import fs from "fs/promises";
import path from "path";

const fileName = "longtext-files";
(async () => {
  const dirPath = path.join(process.cwd(), fileName);
  const files = await fs.readdir(dirPath);
  console.time("Concurrent readFile with Promise.all");

  await Promise.all(files.map((file) => fs.readFile(path.join(dirPath, file))));
  console.timeEnd("Concurrent readFile with Promise.all");
})();

import fs from "fs/promises";
import path from "path";

const fileName = "longtext-files";
(async () => {
  const dirPath = path.join(process.cwd(), fileName);
  const files = await fs.readdir(dirPath);
  console.time("10000개의 파일을 Promise.all");
  let count = 0;
  files.map(async (file) => {
    fs.readFile(path.join(dirPath, file)).then(() => {
      count++;
      if (count === 10000) {
        console.timeEnd("10000개의 파일을 Promise.all");
      }
    });
  });
})();

import { Worker } from "node:worker_threads";
const workerFiles = [
  getFile("1.js"),
  getFile("2.js"),
  getFile("3.js"),
  getFile("4.js"),
];

(async () => {
  console.time("Worker 작업 수행 시간");
  let activateWorker = workerFiles.length;
  workerFiles.forEach((workerFile, i) => {
    const worker = new Worker(workerFile, {
      workerData: files,
    });
    worker.on("message", (message) => {
      if (message === "end") {
        worker.terminate();
        activateWorker--;
        if (activateWorker === 0) {
          console.timeEnd("Worker 작업 수행 시간");
        }
      }
    });
    const rangeStart = Math.floor((i * TOTAL_FILES) / 4);
    const rangeEnd = Math.floor(((i + 1) * TOTAL_FILES) / 4);
    worker.postMessage(`${rangeStart} ${rangeEnd}`);
  });
})();

import fs from "fs/promises";
import path from "path";
import { parentPort, workerData } from "node:worker_threads";

parentPort.on("message", async (message) => {
  const [start, end] = message.split(" ").map(Number);
  const filesToRead = workerData.slice(start, end);
  console.time(`Worker [${start} ~ ${end}] 파일 읽기`);
  await Promise.all(
    filesToRead.map((file) => fs.readFile(path.join(dirPath, file)))
  );
  console.timeEnd(`Worker [${start} ~ ${end}] 파일 읽기`);
  parentPort.postMessage("end");
});