깍돌이

안녕하세요 깍돌이입니다.

기존 포스팅에 이어서 

바로 다음 포스팅에서는 최대워커 수만큼 호출시 와 지금 은 함수를 return new Promise로 해서 Promise.all 로 받았지만

사실 진짜 원하는건 멀티스레드아니였나 

A , B함수에서A가 계속 루프돌고 CPU 연산을 하면 B는 실행도 못하는게 실행되는게 아니였나? 

라는 저만의 질문에 답을 하기 위한 포스팅입니다.

일단 다시 한번 제가 하려고했던 기능을 정리하겠습니다.

A 함수

0.2초마다 A라는 배열을 채웁니다.

B 함수

0.2초마다 A라는 배열에 값이 차면 꺼내와서 테스트 플랫폼에 해당 내용으로 자동화를 요청합니다.

기존 포스팅에서 return new Promise로 했었기 때문에 사실 멀티스레드를 흉내내는지 궁금했습니다.

5개의 함수가 각각 CPU 연산을 할 경우 어떻게 되는가? 입니다.

그럼 실제 연산을 해야되니까 

워커 코드를 아래와같이 변경하였습니다.

Worker.js

'use strict'

// 테스트 용 
let memoryArray = [];

let worker ={
  today_resource_filtering,
  filtered_resource_request_automation,

  today_resource_filtering_node_fn,
  filtered_resource_request_automation_node_fn,

  dummy_fn,
}

let g_closeCondition =100000000;

function today_resource_filtering_node_fn(){
      let i=0;
      let calculatorNumber = 0;
      console.time('today_resource_filtering_node_fn');
      while(true && i < g_closeCondition){
        i++;
        calculatorNumber+=i;
      }
      console.timeEnd('today_resource_filtering_node_fn');
      console.warn(calculatorNumber);
}

function filtered_resource_request_automation_node_fn(){
      let i=0;
      let calculatorNumber = 0;
      console.time('filtered_resource_request_automation_node_fn');
      while(true && i < g_closeCondition){
        i++;
        calculatorNumber+=i;
      }
      console.timeEnd('filtered_resource_request_automation_node_fn');
      console.warn(calculatorNumber);
}

function dummy_fn(name){
  let increNumber=0;
  console.warn(`========Start ${name}`);
  for(let i=0;i<g_closeCondition*50;i++){
      increNumber+=i;
  }
  console.warn(`========End Dummy Fn ${name}`);

}





module.exports = worker;

Node.js ( basic ) 

단순 호출하는 Node.js 입니다. 

let worker = require('./filter_and_request.js');

console.time('using_basic_js');

// 1억 까지 더하는 함수 
console.warn('---------------------Start Today Resource node fn')
worker.today_resource_filtering_node_fn();
console.warn('\r\n');

// 1억 까지 더하는 함수 
console.warn('---------------------Start filtered_resource_request_automation node fn')
worker.filtered_resource_request_automation_node_fn();
console.warn('\r\n');

// 50억 까지 더하는 함수 5번 호출 
for(let i=0;i<5;i++){
  console.warn(`-------------Start dummy calculator fn ${i+1}`);
  worker.dummy_fn(i+1);
  console.warn('\r\n');
}

console.timeEnd('using_basic_js');

Piscina 사용

const path = require('path');
const Piscina = require('piscina');

const piscina = new Piscina({
  filename:path.resolve(__dirname,'filter_and_request.js')
});

console.time('using_Piscina_js');

// 1억 까지 더하는 함수 
console.warn('---------------------Start Today Resource node fn')
piscina.run({},{name:"today_resource_filtering_node_fn"});
console.warn('\r\n');

// 1억 까지 더하는 함수 
console.warn('---------------------Start filtered_resource_request_automation node fn')
piscina.run({},{name:"filtered_resource_request_automation_node_fn"})
console.warn('\r\n');

// 50억 까지 더하는 함수 5번 호출 
for(let i=0;i<5;i++){
  console.warn(`-------------Start dummy calculator fn ${i+1}`);
  piscina.run(i+1,{name:"dummy_fn"});
  console.warn('\r\n');
}

console.timeEnd('using_Piscina_js');

dummy_fn 의 시간을 재기 위해 console.time을 추가했습니다.

function dummy_fn(name){
  let increNumber=0;
  console.warn(`========Start ${name}`);
  console.time(`Check Time ${name}`)
  for(let i=0;i<g_closeCondition*50;i++){
      increNumber+=i;
  }
  console.warn(`========End Dummy Fn ${name}`);
  console.timeEnd(`Check Time ${name}`)

}

결과

Node.js 호출  ( 순차적으로 실행되며 -  57초 발생 ) 

밑에 57초라는게 결국 console.time에서 console.timeEnd가 만나는 시점에 결정되는건데 결국 앞단의 함수들이 CPU 를 집약적으로 사용하고있으면 뒤에 함수는 실행도 못하고 대기하고 있다는 뜻이 됩니다. 

100ms + 100ms + 5s + 5s + 15s + 15s + 15  = 대략 57000 = 57초  ( 동기식 ) 

Piscina 호출 

일단 코드 Blocking되는 부분이 없습니다. using_Piscna_js가 6ms입니다 ( 6s아니고 6s  0.06초입니다. )

이부분을 보면 테스트를 해야하는 코드는 바로 실행하고 넘어갔음을 알수 있습니다.

이로써 Piscina가 worker thread 를 정상적으로 잘 쓰고있는지 정말 worker thread pool 은 기존의 노드 코드를 Blocking하지 않는지 직접 확인해봤는데요 

마지막 포스팅은 제가 원래 하려고했던 작업 ( 하나의 배열을 한쪽은 계속 필터링해서 넣고 -> 한쪽은 배열 차면 꺼내서 테스트 자동화 플랫폼에 테스트 요청을 보내는 ) 에 대한 코드를 올리겠습니다.