something to remember

@Configuration

@Slf4j

public class JwtDecoderConfig {

  @NotBlank

  @Value("${spring.security.oauth2.resourceserver.jwt.issuer-uri}")

  private String  issuerUri;

  @NotBlank

  @Value("${keycloak.truststore}")

  private Resource  trustStore;

  @NotBlank

  @Value("${keycloak.truststore-password}")

  private String  trustStorePw;

  @Bean

  public JwtDecoder jwtDecoder() {

    return  NimbusJwtDecoder

      .withIssuerLocation(issuerUri)

      .restOperations(restTemplate())

      .build();

  }

  private RestTemplate  restTemplate() {

    log.info("RestTemplate for issuer-uri");

    SSLContext sslContext = null;

    try {

      sslContext = new SSLContextBuilder()

        .loadTrustMaterial(trustStore.getURL(), trustStorePw.toCharArray())

        .build();

    } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException

        | IOException e) {

      log.error("ERROR while SSLContext building.", e);

      return  null;

    }

    final TlsSocketStrategy tlsStrategy = new ConscryptClientTlsStrategy(

        sslContext, NoopHostnameVerifier.INSTANCE);

    final HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create()

        .setTlsSocketStrategy(tlsStrategy)

        .setDefaultTlsConfig(TlsConfig.custom()

            .setHandshakeTimeout(Timeout.ofSeconds(30))

            .setSupportedProtocols(TLS.V_1_3)

            .build())

        .build();

    final CloseableHttpClient httpClient = HttpClients.custom()

        .setConnectionManager(cm)

        .build();

    final var requestFactory = new HttpComponentsClientHttpRequestFactory();

    requestFactory.setHttpClient(httpClient);

    return  new RestTemplate(requestFactory);

  }

@Configuration

@EnableWebSecurity

public class SecurityConfig {

  @Autowired

  private CustomKeycloakPreAuthActionsFilter customKeycloakPreAuthActionsFilter;

  @Autowired

  private LicenseCheckFilter  licenseCheckFilter;

  @Autowired

  private JwtDecoder  jwtDecoder;

  private static final int  YEAR_IN_SECOND = 31_536_000;

  @Bean

  protected SecurityFilterChain filterChain(HttpSecurity http) throws Exception {

    return  http

      .addFilterBefore(licenseCheckFilter, BasicAuthenticationFilter.class)

      .addFilterAfter(customKeycloakPreAuthActionsFilter, BasicAuthenticationFilter.class)

      .authorizeHttpRequests(authorize -> authorize

        .requestMatchers(new AntPathRequestMatcher("/mcs/*/system/ping")).permitAll()

        .requestMatchers(new AntPathRequestMatcher("/mcs/*/system/privacy-policies", HttpMethod.GET.name())).permitAll()

        .requestMatchers(

            new AntPathRequestMatcher("/mcs/*/account/request-reset-password-email"),

            new AntPathRequestMatcher("/**/account/reset-password-by-email"),

            new AntPathRequestMatcher("/mcs/*/account/reset-password")

          ).permitAll()

        .requestMatchers(

            new AntPathRequestMatcher("/mcs/*/account/request-activate-email"),

            new AntPathRequestMatcher( "/**/account/activate-by-email"),

            new AntPathRequestMatcher("/mcs/*/account/activate")

          ).permitAll()

        .requestMatchers(new AntPathRequestMatcher("/mcs/*/account/session", HttpMethod.PUT.name())).permitAll()

        .requestMatchers(new AntPathRequestMatcher("/mcs/*/account/session", HttpMethod.POST.name())).permitAll()

        .requestMatchers(

            new AntPathRequestMatcher("/mcs/*/event/**")

          ).permitAll()

        .requestMatchers(new AntPathRequestMatcher("/static/**")).permitAll()

        .requestMatchers(

            new AntPathRequestMatcher("/mcs/**")

        ).hasRole("DASHBOARD")

        // all the REST API's must be matched in the above lines

        .anyRequest().permitAll())

      .csrf(csrf -> csrf

        .ignoringRequestMatchers(

            new AntPathRequestMatcher("/mcs/*/account/**"),

            new AntPathRequestMatcher("/**/license"))

        .csrfTokenRepository(CookieCsrfTokenRepository.withHttpOnlyFalse()))

      .headers(headers -> headers

        .httpStrictTransportSecurity(hsts -> hsts

          .includeSubDomains(true)

          .maxAgeInSeconds(YEAR_IN_SECOND))

        .xssProtection(xss -> xss.headerValue(XXssProtectionHeaderWriter.HeaderValue.ENABLED_MODE_BLOCK))

        .contentSecurityPolicy(csp -> csp.policyDirectives("script-src 'self' 'unsafe-eval'")))

      .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))

      .oauth2ResourceServer(configurer -> configurer

        .jwt(jwtConfigurer -> jwtConfigurer

          .decoder(jwtDecoder)

          .jwtAuthenticationConverter(jwt -> {

            Map<String, Collection<String>> realmAccess = jwt.getClaim("realm_access");

            Collection<String> roles = realmAccess.get("roles");

            var grantedAuthorities = roles.stream()

              .map(role -> new SimpleGrantedAuthority("ROLE_" + role.toUpperCase()))

              .toList();

            return new JwtAuthenticationToken(jwt, grantedAuthorities);

          })))

      .build();

  }

private RestClient restClient;

@PostConstruct private void init() {

log.info("init");

SSLContext context; try { context = SSLContextBuilder.create() .loadTrustMaterial(trustStore.getURL(), trustStorePw.toCharArray()) .build(); } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException | IOException e) { log.error("SSL context not built", e); throw new CoreException(ReasonEnum.CONNECTION_ERROR, "SSL context not built", e); }

final TlsSocketStrategy tlsStrategy = new ConscryptClientTlsStrategy( context, NoopHostnameVerifier.INSTANCE); final HttpClientConnectionManager cm = PoolingHttpClientConnectionManagerBuilder.create() .setDefaultSocketConfig( SocketConfig.custom().setSoTimeout(Timeout.ofMilliseconds(READ_TIMEOUT)).build()) .setMaxConnTotal(MAX_CONNECITION) .setMaxConnPerRoute(MAX_CONNECTION_PER_ROUTE) .setTlsSocketStrategy(tlsStrategy) .setDefaultTlsConfig(TlsConfig.custom() .setHandshakeTimeout(Timeout.ofSeconds(30)) .setSupportedProtocols(TLS.V_1_3) .build()) .build(); final CloseableHttpClient httpClient = HttpClients.custom() .setConnectionManager(cm) .build(); final var factory = new HttpComponentsClientHttpRequestFactory(); factory.setConnectTimeout(CONNECTION_TIMEOUT); factory.setHttpClient(httpClient);

Now I regrect why I have forgotten that there's no Silver bullet. We cannot keep transaction safe and Saga pattern seems to be another B.S.

I have waited for vscode team to make the outline window detachable, but it seems that it's rather challenging than I expected. Then I found Theia.

It have almost same look with vscode but outline window is on the right side.

below is my test setting(package.json)

{ "private": true, "dependencies": { "@theia/callhierarchy": "next", "@theia/file-search": "next", "@theia/git": "next", "@theia/json": "next", "@theia/markers": "next", "@theia/messages": "next", "@theia/mini-browser": "next", "@theia/navigator": "next", "@theia/outline-view": "next", "@theia/plugin-ext-vscode": "next", "@theia/preferences": "next", "@theia/preview": "next", "@theia/search-in-workspace": "next", "@theia/terminal": "next", "@theia/debug": "next" }, "devDependencies": { "@theia/cli": "next" }, "scripts": { "prepare": "yarn run clean && yarn build && yarn run download:plugins", "clean": "theia clean", "build": "theia build --mode development", "start": "theia start --plugins=local-dir:plugins", "download:plugins": "theia download:plugins" }, "theiaPluginsDir": "plugins", "theiaPlugins": { "vscode-builtin-node-debug2": "http://open-vsx.org/api/ms-vscode/node-debug2/1.33.0/file/ms-vscode.node-debug2-1.33.0.vsix", "vscode-builtin-python": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/python-1.39.1-prel.vsix", "vscode-builtin-java": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/java-1.39.1-prel.vsix", "vscode-builtin-sql": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/sql-1.39.1-prel.vsix", "vscode-builtin-bat": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/bat-1.39.1-prel.vsix", "vscode-builtin-cpp": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/cpp-1.39.1-prel.vsix", "vscode-builtin-css": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/css-1.39.1-prel.vsix", "vscode-builtin-html": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/html-1.39.1-prel.vsix", "vscode-builtin-javascript": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/javascript-1.39.1-prel.vsix", "vscode-builtin-json": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/json-1.39.1-prel.vsix", "vscode-builtin-markdown": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/markdown-1.39.1-prel.vsix", "vscode-builtin-npm": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/npm-1.39.1-prel.vsix", "vscode-builtin-scss": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/scss-1.39.1-prel.vsix", "vscode-builtin-typescript": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/typescript-1.39.1-prel.vsix", "vscode-builtin-typescript-language-features": "https://github.com/theia-ide/vscode-builtin-extensions/releases/download/v1.39.1-prel/typescript-language-features-1.39.1-prel.vsix" } }

and launch.json sample to debug node.js code.

{ // Use IntelliSense to learn about possible attributes. // Hover to view descriptions of existing attributes. "version": "0.2.0", "configurations": [ { "type": "node2", "request": "attach", "name": "Attach by Process ID", "processId": "${command:PickProcess}", "skipFiles": [ "/**" ] }, { "type": "node2", "request": "launch", "name": "Launch Program", "skipFiles": [ "/**" ], "program": "${workspaceFolder}\\test1\\test.js" } ] }

image file upload 후 꺼내서 화면에 표시해야하는데, 400 error 발생

1 tomcat 7에서는 문제 없는데, tomcat 8만 발생하며 해당 파일은 브라우저에서 URL입력해도 읽어오지 못함.

2 이미지 파일 업로드 시 파일명에 날짜를 추가하는데 앞뒤로 "[]"를 추가하며 발생한 문제. 원래 해당 character는 URL에 사용하면 안됨. (https://tomcat.apache.org/tomcat-8.5-doc/config/http.html)

3 파일명을 URLEncoder.encode(..., "UTF-8) 로 변경하면 동작.

JPA를 이용해 find...()할 경우 OrderBy를 이용해서 sorting 가능.

public ??? findBySoundCategoryOrderByIndexAsc(Integer soundCategory);

하지만, findAll()은 OrderBy 를 그대로 사용할 수 없다.

Exception은 try-catch 필수, RuntimeException은 안해도 됨.

multicatch 블럭의 exception object

걸려있는 모든 excpetion의 조상 class의 method만 사용 가능.

값을 변경할 수 없음.

finally는 try나 catch 블럭에 return이 있어도 실행됨. return type이 void가 아닌 경우 try, catch가 아닌 finally의 값이 return됨. return 문에서 side-effect가 발생하는 경우라면?

try-with-resource -JDK1.7 이후

try { fis = new FileInputStream("score.dat"); dis =- new DataInputStream(fis); ... } catch(IOException ie) { ie.printStackTrace(); } finally { try { if(dis != null) dis.close(); } catch(IOException ie) { ie.printStackTrace(); } }

아래와 같이 변경 가능.

try(FileInputStream fis = new FileInputStream("score.data"); DataInputStream dis = new DataInputStream(fis)) { ... } catch(IOException ie) { ie.printStackTrace(); }

try 블럭을 벗어나면서 close()가 호출되고 이후 catch 블럭이나 finally 블럭이 수행됨.

try 블럭 안에 변수 선언 가능.

자동으로 close()가 호출되려면 AutoCloseable interface를 구현해야 함. try 블럭에서 exception 발생 후 close()에서 exception이 또 발생할 경우 후자는 supress됨.

연결된 exception

exception 발생 시 catch 블럭에서 해당 exception을 새로운 exception에 initCause()로 저장 후 새로운 exception을 throw.

여러가지 exception을 상속관계 없이 하나의 exception으로 처리 가능.

팔자에도 없던 spring project를 위해 https://www.inflearn.com/course/%ec%9e%90%eb%b0%94-%ec%8a%a4%ed%94%84%eb%a7%81-%ea%b0%95%ec%a2%8c/ 에서 spring 강좌 수강하던 중, '21강 JDBC'에서 실습이 막힘. 그 전까지는 oracle로 된 실습 코드를 maria DB에 맞춰 어찌어찌 해왔는데...

일단 pom.xml에 아래 내용 추가

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>4.3.18.RELEASE</version> </dependency>

이렇게 해도 "Error: BeanDefinitionStoreException failed to read candidate component class" error 발생. 검색해보니 https://www.javagists.com/beandefinitionstoreexception-failed-to-read-candidate-component-class 와 몇군데에서 spring과 java version이 맞아야 한다고 나옴. 설치된 jdk는 1.8이었고 이 버전은 spring 4.x를 사용해야한다고 하는데, pom.xml에는 spring 3.1로 되어있음. 그리고 pom.xml의 java version은 1.6임. 무슨 경우인지???

일단 pom.xml의 java version 1.8로 바꾸고 https://www.sity.kr/yc5/bbs/board.php?bo_table=webinfo&wr_id=56 참고해서 spring version을 4.3.4.RELEASE로 변경. 그리고 관계있는지 모르겠지만 jsp-api 2.2로 바꿈. servlet-api는 3.0으로 바꾸면 동작 안함.

std::vector<>를 iterate할 때 어떤 방법이 더 빠를까?

#include <vector> #include <iostream> #include <chrono> #include <random> #include <ctime> #include <algorithm> #define VECTOR_SIZE 10000000 int main() { volatile double sum; std::vector v(VECTOR_SIZE); unsigned seed1 = std::chrono::system_clock::now().time_since_epoch().count(); std::mt19937 g(seed1); std::for_each(v.begin(), v.end(), [&g](double &d) { d = g(); }); sum = 0; auto t1 = std::chrono::system_clock::now(); std::for_each(v.begin(), v.end(), [&sum](double d) { sum += d; }); auto t2 = std::chrono::system_clock::now(); auto diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; sum = 0; t1 = std::chrono::system_clock::now(); for(double d : v) sum += d; t2 = std::chrono::system_clock::now(); diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; sum = 0; t1 = std::chrono::system_clock::now(); for(auto it = v.begin(); it != v.end(); ++it) sum += *it; t2 = std::chrono::system_clock::now(); diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; sum = 0; t1 = std::chrono::system_clock::now(); for(int i=0; i<VECTOR_SIZE; ++i) sum += v[i]; t2 = std::chrono::system_clock::now(); diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; return 0; }

환경: CTO cloud, ubuntu 14, 16 core, ...

compile: g++ -std=c++11 -O0 main.cpp

결과

for_each: 106.046 range-based for: 86.0454 iterator: 146.815 for: 52.5619

for가 가장 빠르고 그 다음이 range-based for, std::for_each이고, iterator를 사용하는 경우가 가장 느림(for의 3배 정도).

std::set<>의 경우는?

for는 사용할 수 없으므로 제외.

결과

for_each: 141.654 range-based for: 143.641 iterator: 150.167

export

test1.sh

#!/bin/bash -e export CROSS='asdf' echo $CROSS ./test2.sh

test2.sh

#!/bin/bash -e echo 'test2' echo $CROSS

test1.sh 실행 결과

asdf test2 asdf

if-not

test.sh

#!/bin/bash XX=1 echo $XX echo $YY if ! [ $XX ]; then echo XX fi if ! [ $YY ]; then echo YY fi

test.sh 실행 결과

1 YY

variable

test.sh

#!/bin/bash -e testvar="asdf" echo testvar echo $testvar echo ${testvar} echo "$testvar" echo '$testvar'

test.sh 실행 결과

testvar asdf asdf asdf $testvar

결과 저장

test.sh

#!/bin/bash AAA="AAA" echo $AAA R1=$(cat test1.sh) echo $R1 R2=$(cat $AAA) echo $R2

AAA

AAAA

test.sh 실행 결과

AAA #!/bin/bash AAA="AAA" echo $AAA R1=$(cat test1.sh) echo $R1 R2=$(cat $AAA) echo $R2 AAAA

command line argument

test.sh

#!/bin/bash echo $# if [ $# -eq 0 ] then echo "more arguments..." exit fi for i in $* do echo $i done

test.sh 1 2 3 실행 결과

파일 저장 시 입력받은 string으로 파일명을 만들어야하는데, 파일명으로 사용할 수 없는 글자가 포함되어 있는지 check해야 함.

platform마다 조건이 다르고, 너무 복잡하게 하기 싫어서 영문 대/소문자, 숫자, '-', '_', '~', ' '(space)만 허용.

세가지 방법으로 테스트

#include <ctime> #include <chrono> #include <string> #include <iostream> #include <regex> bool findChar1(const char c) { if('a' <= c && c <= 'z') return true; if('A' <= c && c <= 'Z') return true; if('0' <= c && c <= '9') return true; if(c == '-' || c == '_' || c == '~' || c == ' ') return true; return false; } bool findChar2(const char c) { static std::string validCharacters("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_~ "); return !(validCharacters.find(c) == std::string::npos); } bool findChar3(const char c) { std::regex r("[a-zA-Z0-9\\-_~ ]"); static std::string str(1, ' '); str[0] = c; return std::regex_match(str, r); } int main() { char v[10000]; const int REPEAT = 100; for(int i=0; i<10000; ++i) v[i] = 32+(i%95); // 1 auto t1 = std::chrono::system_clock::now(); for(int j=0; j<REPEAT; ++j) for(int i=0; i<10000; ++i) findChar1(v[i]); auto t2 = std::chrono::system_clock::now(); auto diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; // 2 t1 = std::chrono::system_clock::now(); for(int j=0; j<REPEAT; ++j) for(int i=0; i<10000; ++i) findChar2(v[i]); t2 = std::chrono::system_clock::now(); diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; // 3 t1 = std::chrono::system_clock::now(); for(int j=0; j<REPEAT; ++j) for(int i=0; i<10000; ++i) findChar3(v[i]); t2 = std::chrono::system_clock::now(); diff = t2-t1; std::cout << std::chrono::duration<double, std::milli>(diff).count() << std::endl; return 0; } // PC(mingw g++ 7.1.0) // 6.001 // 52.005 // 175658

가장 쉽게 생각할 수 있는, char가 ascii값이라는 가정으로 확인하는 방법이 가장 빠르며, 가능한 글자들로 string을 만들어 find()함수 사용하는 방법이 두번째, std::regex가 가장 느림.

각 방법의 속도 차이가 크게 나며 특히 regex는...(원래 만들어진 목적 생각하면 당연하지만).

regex는 ubuntu 14의 gcc4.8에서 컴파일은 되지만 실행 시 crash 발생.

어느날 생긴 의문

어떤 container의 멤버들에 대해 테스트를 가한 후 그 결과를 std::deque<bool>에 저장함(vector<>를 사용하지 않은 이유는 ESTL item 18 참고).

deque 안의 모든 결과가 true이면 함수의 결과가 true, 그렇지 않으면 false여야하는 상황.

std::all_of(), std::accumulate(), std::find()를 사용할 수 있을 텐데, short-circuit이 발생하는지? 그리고 어느 방법이 빠른지? 혹시 for를 사용해 short-circuit을 발생시키면 더 빠르진 않을지?

아래의 실행 결과는 cpp.sh에서 실행한 결과임.

short-circuit 발생 여부

#include <deque> #include <iostream> #include <algorithm> int main() { std::deque<bool> input{false, true}; std::cout << std::all_of(input.cbegin(), input.cend(), [](const bool x) { std::cout << '!'; return x; }) << std::endl; std::cout << std::accumulate(input.cbegin(), input.cend(), true, [](const bool x, const bool y) { std::cout << '!'; return x && y; }) << std::endl; std::cout << (std::find_if(input.cbegin(), input.cend(), [](const bool x) { std::cout << '!'; return x == false; }) == input.cend()) << std::endl; return 0; } // result: // !0 // !!0 // !0

위 코드 실행 결과 std::all_of(), std::find_if()는 short-circuit 발생하며 std::accumulate()는 short-circuit 발생하지 않음(당연히 predicate 안에서 발생할 side-effect를 유지하기 위해서 겠지).

따라서 std::find()도 short-circuit이 발생하리라 예상되고...

실행 속도

#include <iostream> #include <algorithm> #include <deque> #include <chrono> bool d1(const std::deque<bool> &in) { return std::all_of(in.cbegin(), in.cend(), [](const bool x) { return x; }); } bool d2(const std::deque<bool> &in) { return std::accumulate(in.cbegin(), in.cend(), true, [](const bool x, const bool y) { return x && y; }); } bool d3(const std::deque<bool> &in) { for(auto i : in) if(!i) return false; return true; } bool d4(const std::deque<bool> &in) { return std::find(in.cbegin(), in.cend(), false) == in.end(); } int main() { std::deque<bool> t1{false, false, false, false}; std::deque<bool> t2{true, false, true, false}; std::deque<bool> t3{false, true, false, true}; std::deque<bool> t4{true, true, true, true}; auto tm1 = std::chrono::system_clock::now(); std::cout << d1(t1) << d1(t2) << d1(t3) << d1(t4) << std::endl; auto tm2 = std::chrono::system_clock::now(); std::cout << std::chrono::duration<double, std::milli>(tm2-tm1).count() << std::endl; tm1 = std::chrono::system_clock::now(); std::cout << d2(t1) << d2(t2) << d2(t3) << d2(t4) << std::endl; tm2 = std::chrono::system_clock::now(); std::cout << std::chrono::duration<double, std::milli>(tm2-tm1).count() << std::endl; tm1 = std::chrono::system_clock::now(); std::cout << d3(t1) << d3(t2) << d3(t3) << d3(t4) << std::endl; tm2 = std::chrono::system_clock::now(); std::cout << std::chrono::duration<double, std::milli>(tm2-tm1).count() << std::endl; tm1 = std::chrono::system_clock::now(); std::cout << d4(t1) << d4(t2) << d4(t3) << d4(t4) << std::endl; tm2 = std::chrono::system_clock::now(); std::cout << std::chrono::duration<double, std::milli>(tm2-tm1).count() << std::endl; return 0; } // result(-O0) // 0001 // 0.049588 // 0001 // 0.004838 // 0001 // 0.003079 // 0001 // 0.004162 // result(-O2) // 0001 // 0.044687 // 0001 // 0.003287 // 0001 // 0.002384 // 0001 // 0.002644

(당연히) 결과는 같으며 속도는 for 문 사용한 경우가 가장 빠름.

의외로 std::all_of()가 std::accumulate()나 std::find()보다 10배 이상 시간이 많이 걸림.

Ratio

Represent rational number

Used in std::chrono::duration class

일반적인 object를 만들거나(compile-time constant) method를 호출할 수 없으며 typedef를 사용해야한다.

typedef ratio<1, 60> r1; // OK intmax_t n=1; intmax_t d=60; typedef ratio r2; // ERROR

library는 아래와 같은 값을 제공한다.

typedef ratio<1, 1000000000000000000000000> yocto; typedef ratio<1, 1000000000000000000000> zepto; typedef ratio<1, 1000000000000000000> atto; typedef ratio<1, 1000000000000000> femto; typedef ratio<1, 1000000000000> pico; typedef ratio<1, 1000000000> nano; typedef ratio<1, 1000000> micro; typedef ratio<1, 1000> milli; typedef ratio<1, 100> centi; typedef ratio<1, 10> deci; typedef ratio< 10, 1> deca; typedef ratio< 100, 1> hecto; typedef ratio< 1000, 1> kilo; typedef ratio< 1000000, 1> mega; typedef ratio< 1000000000, 1> giga; typedef ratio< 1000000000000, 1> tera; typedef ratio< 1000000000000000, 1> peta; typedef ratio< 1000000000000000000, 1> exa; typedef ratio< 1000000000000000000000, 1> zetta; typedef ratio<1000000000000000000000000, 1> yotta;

Duration

duration class는 tick의 수와 tick period를 저장한다.

tick period는 두 tick 사이의 초단위 시간이며 ratio로 표현된다.

template <class Rep, class Period = ratio<1>> class duration {...}

Rep는 tick의 수를 저장할 변수의 type이며, Period는 tick의 간격을 나타내는 rational constant이다(default는 1초).

산술연산과 비교연산이 가능하다.

example:

duration<long, ratio<60>> d3(10); // 10 minutes duration<long, ratio<1>> d4(14); // 14 seconds

library에 아래와 같은 값들이 정의되어 있다(X means "signed interger type of at least").

typedef duration<X 64 bits, nano> nanoseconds; typedef duration<X 55 bits, micro> microseconds; typedef duration<X 45 bits, milli> milliseconds; typedef duration<X 35 bits> seconds; typedef duration<X 29 bits, ratio<60>> minutes; typedef duration<X 23 bits, ratio<3600>> hours;

정수로 나누어지지 않는 값은 compile error를 발생시킨다. 이는 값에 의해 판단되지 않으며 type에 의해 판단된다. 아래 예의 두번째, 네번째 코드와 같이 초로부터 분을 얻을 경우 나누어지지 않을 가능성이 있으므로 error가 발생한다.

seconds s(90); minutes m(s); // ERROR seconds ss(60); minutes mm(ss); // ERROR

Clock

clock은 time_point와 duration으로 이루어진다.

표준은 3개의 clock을 정의한다.

steady_clock의 time_point는 작아지지 않는다.

system_clock은 언제든지 값을 변경할 수 있다.

high_resolution_clock은 가장 작은 tick period를 가진다. compiler에 따라 steady_clock이나 system_clock과 같을 수 있다.

각 clock은 현재 시간을 time_point로 얻을 수 있는 static method now()를 가진다.

C-style time_t와 time_point 간의 변경을 위해 to_time_t(), from_time_t() 함수를 제공한다.

auto start = system_clock::now(); // do some job auto end = system_clock::now(); auto diff = end - start; cout << duration<<double, milli>(diff).count() << "ms" << endl;

Time point

A point in time is represented by the time_point class and stored as a duration relative to the epoch.

time_point는 항상 특정 clock과 연관되어있으며 epoch는 연관된 clock의 origin이다. 예를 들어 classic Unix/Linux의 epoch는 1970년 1월 1일이며 duration은 초로 계산된다.

time_point는 epoch로부터 경과시간(duration)을 알려주는 time_since_epoch() 함수를 가진다.

thread-based

int doAsyncWork(); std::thread t(doAsyncWork);

task-based

int doAsyncWork(); auto fut = std::async(doAsyncWork); // std::future type

task-based의 장점

std::async에서 return된 std::future의 get() 이용해서 결과를 얻을 수 있다.

exception을 잡을 수 있다(thread-based인 경우 프로그램이 죽게됨).

thread 관리를 자동으로 해줌.

thread 개수가 모자라거나 oversubscription될 경우에 대한 최적화. - thread 개수가 모자랄 경우 호출한 thread에서 get()을 실행.

thread를 사용해야할 경우

thread 구현(pthread, window thread)의 API를 이용해야할 경우(ex. priority 설정).

최적화를 직접 수행해야할 경우.

thread 간 통신이 필요할 때 사용할 수 있는 방법들

condition variable

std::condition_variable cv; std::mutex m; // detecting task ... cv.notify_one(); // reacting task { std::unique_lock<std::mutex> lk(m); cv.wait(lk); ... }

problem

mutex의 원래 목적인 resource에 대한 접근 관리가 아닌 thread 흐름제어에 mutex를 이용함.

wait()보다 notify가 먼저 실행되면 reacting task가 종료되지 않음.

spurious wakeups에 의해 wait() 실패. 이를 해결하기 위해서 detecting task가 정상 동작했는지 확인 필요.

flag

std::atomic<bool> flag(false); // detecting task flag = true; // reacting task while(!flag) ; ...

problem

reacting task에서 대기하는 동안 polling 해야 함.

1, 2를 개선

std::condition_variable cv; std::mutex m; bool flag(false); // detecting task { std::lock_guard<std::mutex> g(m); flag = true; } cv.notify_one(); // reacting task { std::unique_lock<std::mutex> lk(m); cv.wait(lk, [] { return flag; }); ... } ...

problem

condition_variable과 mutex를 이용함.

future 이용

std::promise<void> p; void react(); void detect() { std::thread t([] { p.get_future().wait(); react(); }); ... // CAUTION! p.set_value(); ... t.join(); }

problem

promise와 future 간의 shared state를 dynamic allocation 하기위한 비용.

promise에 한번 값을 설정하고나면 이후 사용 불가.