#pragma omp critical [(lock_name)]

#pragma omp parallel for

for (i=0; i<MAX_ITERATION; i++) {

    process_a();

    chk_process();

    process_b();

    chk_process();

    process_c();

    chk_summary();

}

#pragma omp parallel for

for (i=0; i<MAX_ITERATION; i++) {

    process_a();

#pragma omp critical

    chk_process();

    process_b();

#pragma omp critical

    chk_process();

    process_c();

    chk_summary();

}

#pragma omp parallel for

for (i=0; i<MAX_ITERATION; i++) {

    process_a();

#pragma omp critical (lock1)

    chk_process();

    process_b();

#pragma omp critical (lock1)

    chk_process();

    process_c();

#pragma omp critical (lock2)

    chk_summary();

}

#pragma omp atomic

#pragma omp parallel

...생략...;

#pragma omp atomic

    n_count++;

}

#include <omp.h>

int main()

{

    omp_set_dynamic(1);

#pragma omp parallel num_threads(10)

{

    /* do work here */

}

    return 0;

}

double start;

double end;

start = omp_get_wtime();

    ... work to be timed ...

end = omp_get_wtime();

printf("Work took %f seconds\n", end - start);

export OMP_SCHEDULE="dynamic"

export OMP_SCHEDULE "guided,4"

export OMP_NUM_THREADS 16

export OMP_DYNAMIC true

export OMP_NESTED false

#include <stdio.h>

int main()

{

# ifdef _OPENMP

    printf("Compiled by an OpenMP-compliant implementation.\n");

# endif

    return 0;

}

#include <stdio.h>

#include <stdlib.h>

int num_steps=1000000000; /* 10억번 : 너무 많으면 조금 줄이시길... */



int main()

{

    int i;

    double x, step, sum = 0.0;

    step = 1.0/(double) num_steps;

#pragma omp parallel for private(x) reduction(+:sum)

    for (i=0; i<num_steps; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

#include <stdio.h>

#include <stdlib.h>

#include <pthread.h>



static int num_steps=1000000000;

double pi, step;

struct start_arg {

    int     i_start;

    int     i_end;

    double  sum;

} start_arg[2];



void *start_func(void *arg)

{

    int     i;

    double  x, sum = 0.0;

    struct start_arg *p_arg = (struct start_arg *) arg;



    for (i=p_arg->i_start; i<p_arg->i_end; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    p_arg->sum = sum;

    return NULL;

}



int main()

{

    int     i;

    double  sum;

    pthread_t   pt_id[2];



    step = 1.0/(double) num_steps;

    start_arg[0].i_start = 0;

    start_arg[0].i_end   = num_steps>>1;

    start_arg[1].i_start = start_arg[0].i_end + 1;

    start_arg[1].i_end   = num_steps;



    printf("%d~%d, %d~%d\n",

            start_arg[0].i_start, start_arg[0].i_end ,

            start_arg[1].i_start, start_arg[1].i_end );



    for (i=2; i--; ) { /* create pthread */

        if (pthread_create(&pt_id[i], NULL, start_func, &start_arg[i])){

            perror("pthread_create");

            return 1;

        }

    }

    for (i=2; i--; ) { /* join pthread : explicit barrier */

        if (pthread_join(pt_id[i], NULL)){

            perror("pthread_join");

            return 1;

        }

    }

    sum = start_arg[0].sum + start_arg[1].sum;

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

$ time ./pi_integration

PI = 3.14159265 (sum = 3141592653.59036255)



real    0m3.910s

user    0m7.484s

sys    0m0.018s

$ time ./pi_integration_pth

0~500000000, 500000001~1000000000

PI = 3.14159265 (sum = 3141592650.38979244)



real    0m4.071s

user    0m7.399s

sys    0m0.022s

1. 멀티 쓰레드 프로그램의 문제점 : 디버깅이 힘들다. (재현성이 나쁘기 때문)
2. 아키텍처와 메모리 모델에 대한 이해가 필요하다. (본인도 부족하다. 그래서 실수를 할 때가 있다.)

$ cat $ORACLE_HOME/install/portlist.ini

Enterprise Manager 콘솔 HTTP 포트(orcl) = 5500

Enterprise Manager 에이전트 포트(orcl) = 3938

$ emctl start dbconsole

[oracle@localhost ~]$ cd $ORACLE_HOME

[oracle@localhost dbhome_1]$ ls

EMStagePatches_orcl  ctx               instantclient   mesg         owm           srvm

OPatch               cv                inventory       network      perl          sysman

apex                 dbs               j2ee            nls          plsql         timingframework

assistants           dc_ocm            javavm          oc4j         precomp       ucp

bin                  deinstall         jdbc            odbc         racg          uix

ccr                  demo              jdev            olap         rdbms         utl

cdata                diagnostics       jdk             ons          relnotes      wwg

cfgtoollogs          emcli             jlib            opmn         root.sh       xdk

clone                has               ldap            oraInst.loc  scheduler

config               hs                lib             oracore      slax

crs                  ide               localhost_orcl  ord          sqldeveloper

csmig                install           log             oui          sqlj

css                  install.platform  md              owb          sqlplus

$ export ORACLE_HOSTNAME=localhost

$ emctl start dbconsole

Oracle Enterprise Manager 11g Database Control Release 11.2.0.1.0 

Copyright (c) 1996, 2009 Oracle Corporation.  All rights reserved.

https://localhost:1158/em/console/aboutApplication

Starting Oracle Enterprise Manager 11g Database Control ........

------------------------------------------------------------------

Logs are generated in directory /u01/app/oracle/product/11.2.0/dbhome_1/localhost_orcl/sysman/log

• 호스트 1: Fedora 9
• 호스트 2: Fedora 11

[root@localhost ~]# sestatus

SELinux status:                 enabled

SELinuxfs mount:                /selinux

Current mode:                   enforcing

Mode from config file:          enforcing

Policy version:                 24

Policy from config file:        targeted

[root@localhost ~]# setenforce permissive

[root@localhost ~]# sestatus

SELinux status:                 enabled

SELinuxfs mount:                /selinux

Current mode:                   permissive

Mode from config file:          enforcing

Policy version:                 24

Policy from config file:        targeted

# This file controls the state of SELinux on the system.

# SELINUX= can take one of these three values:

#       enforcing - SELinux security policy is enforced.

#       permissive - SELinux prints warnings instead of enforcing.

#       disabled - No SELinux policy is loaded.

SELINUX=enforcing

# SELINUXTYPE= can take one of these two values:

#       targeted - Targeted processes are protected,

#       mls - Multi Level Security protection.

SELINUXTYPE=targeted

• RAM 메모리 : 2G 이상 (최소 1G이지만 2G는 되어야 한다.)
• SWAP 메모리 : RAM 크기 or 최대 2배 (RAM이 2G이면 SWAP도 2G정도면 충분하다.)

이제는 디스크 공간을 확인해야 한다.

• Oracle 11g 압축을 풀어놓을 임시 공간 : 약 3G
• Oracle 11g 프로그램을 설치할 공간 : 약 7G
• Oracle 데이터베이스를 구축할 공간 : 약 4G
• /tmp 디렉토리 : 최소 400M 정도의 빈 공간

# groupadd oinstall

# groupadd dba

# useradd -g oinstall -G dba oracle

# passwd oracle

# cat /etc/pam.d/login

#%PAM-1.0

auth [user_unknown=ignore success=ok ignore=ignore default=bad] pam_securetty.so

auth       include      system-auth

account    required     pam_nologin.so

account    include      system-auth

password   include      system-auth

# pam_selinux.so close should be the first session rule

session    required     pam_selinux.so close

session    required     pam_loginuid.so

session    optional     pam_console.so

# pam_selinux.so open should only be followed by sessions to be executed in the user context

session    required     pam_selinux.so open

session    required     pam_namespace.so

session    optional     pam_keyinit.so force revoke

session    include      system-auth

-session   optional     pam_ck_connector.so

session    required     pam_limits.so

# mkdir /u01/app

# chown -R oracle:oinstall /u01 

ORACLE_BASE=/u01/app/oracle

ORACLE_SID=orcl

export ORACLE_BASE ORACLE_SID

[oracle@localhost database]$ ./runInstaller 

Oracle Universal Installer 시작 중...



임시 공간 확인 중: 80MB 이상이어야 합니다..   실제 728MB    성공

스왑 공간 확인 중: 150MB 이상이어야 합니다..   실제 511MB    성공

모니터 확인 중: 최소 256 색상을 표시하도록 구성되어 있어야 합니다..    실제 16777216    성공

다음에서 Oracle Universal Installer의 시작을 준비하는 중 /tmp/OraInstall2009-10-06_03-39-30PM. 기다리십시오.

[root@localhost ~]# /opt/app/oracle/product/11.2.0/dbhome_1/root.sh 

Running Oracle 11g root.sh script...



The following environment variables are set as:

    ORACLE_OWNER= oracle

    ORACLE_HOME=  /opt/app/oracle/product/11.2.0/dbhome_1



Enter the full pathname of the local bin directory: [/usr/local/bin]: 

   Copying dbhome to /usr/local/bin ...

   Copying oraenv to /usr/local/bin ...

   Copying coraenv to /usr/local/bin ...



Creating /etc/oratab file...

Entries will be added to the /etc/oratab file as needed by

Database Configuration Assistant when a database is created

Finished running generic part of root.sh script.

Now product-specific root actions will be performed.

Finished product-specific root actions.

ORACLE_BASE=/u01/app/oracle

ORACLE_SID=orcl

ORACLE_HOME=/u01/app/oracle/product/11.2.0/dbhome_1

export ORACLE_BASE ORACLE_HOME ORACLE_SID



if [ x`echo $PATH | grep $ORACLE_HOME/bin` = 'x' ]; then

    echo "Setting oracle binary path: $ORACLE_HOME/bin"

    PATH=$PATH:$ORACLE_HOME/bin

    export PATH

fi



if [ x`echo $LD_LIBRARY_PATH | grep $ORACLE_HOME/lib` = 'x' ]; then

    echo "Setting oracle LD_LIBRARY_PATH : $ORACLE_HOME/lib"

    if [ x$LD_LIBRARY_PATH = 'x' ]; then

        LD_LIBRARY_PATH=$ORACLE_HOME/lib

    else

        LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$ORACLE_HOME/lib

    fi

    export LD_LIBRARY_PATH

fi

• single construct는 처음으로 진입한 쓰레드가 실행한다.
• 나머지 쓰레드들은 single construct 끝에 존재하는 implicit barrier에서 대기한다.
• single construct가 끝나고 모든 쓰레드들은 implicit barrier에서 동시에 시작한다.

$ gcc -o omp_single -fopenmp omp_single.c

$ ./omp_single

1. Hello world

2. Hello world

2. Hello world

• master construct 구간은 무조건 master thread (main thread)가 1번 실행한다.
• master construct 구간뒤에 implicit barrier가 없다.
  즉 모든 쓰레드는 master construct 실행되는 동안에도 계속 실행한다.

• #pragma omp parallel
• #pragma omp for
• #pragma omp single

• #pragma omp barrier 구문을 지정하면 해당 부분에서 모든 쓰레드가 도착할 때까지 대기하게 된다.

char * get_time0(char *buf, size_t sz_buf);



int main()

{

    int     t_sleep; char    buf[16];

#pragma omp parallel private(t_sleep, buf)

    {

#pragma omp single nowait

        sleep(1);

        printf("[%s] phase1:sleep %ld sec.\n", get_time0(buf, sizeof(buf)), t_sleep = times(NULL)%8);

        sleep(t_sleep);

#pragma omp barrier

        /* explicit barrier */

        printf("[%s] phase2. Hello world\n", get_time0(buf, sizeof(buf)));

    }

    return 0;

}



char * get_time0(char *buf, size_t sz_buf)

{

    time_t  t0; struct tm   tm_now;

    if (buf == NULL) return NULL;

    if (time(&t0) == ((time_t)-1)) return NULL;

    localtime_r(&t0, &tm_now);

    if (strftime(buf, sz_buf, "%H:%M:%S", &tm_now) == 0) return NULL;

    return buf;

}

$ ./omp_barrier

[19:12:27] phase1:sleep 1 sec.

[19:12:28] phase1:sleep 5 sec.

[19:12:33] phase2. Hello world

[19:12:33] phase2. Hello world

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#define LOOP_ITERATION 200000000

int    hits;



int main()

{

    int 	i;

    double 	x, y, rns;

    time_t	t_now;



    printf("Loop iteration = %ld\n", (long)LOOP_ITERATION);

    rns = 1.0/(double)RAND_MAX;



    t_now = time(0);

    srand((unsigned int)t_now);

    for (i=0; i<LOOP_ITERATION; i++) {

        x = (double)rand() * rns;

        y = (double)rand() * rns;

        if (x*x + y*y < 1) {

            hits++;

        }

    }

    printf("pi = %f\n", 4*(double)hits/LOOP_ITERATION);

    return 0;

}

$ gcc -o pi_monte pi_monte.c

$ time ./pi_monte

Loop iteration = 200000000

pi = 3.141588



real    0m8.726s

user    0m8.702s

sys 0m0.023s

...생략...

#pragma omp parallel for private(x,y) reduction(+:hits)

for (i=0; i<LOOP_ITERATION; i++) {

    x = (double)rand() * rns;

    y = (double)rand() * rns;

    if (x*x + y*y < 1) {

        hits++;

    }

}

...생략...

$ gcc -o pi_monte_omp -fopenmp pi_monte.c

$ time ./pi_monte_omp 

Loop iteration = 200000000

pi = 3.141513



real    0m54.909s

user    0m54.173s

sys 0m53.115s

#define _REENTRANT

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#ifdef LOOP_ITERATION

#define LOOP_ITERATION 200000000

#endif

int    hits;



int main()

{

    unsigned int state;

    int     i;

    double  x, y, rns;

    printf("Loop iteration = %ld\n", (long)LOOP_ITERATION);

    rns = 1.0/(double)RAND_MAX;

    state = (unsigned int)time(0);

#pragma omp parallel for firstprivate(state) private(x, y) reduction(+:hits)

    for (i=0; i<LOOP_ITERATION; i++) {

        x = (double)rand_r(&state) * rns;

        y = (double)rand_r(&state) * rns;

#if LOOP_ITERATION < 100

        printf("THR[%d:%d] x,y/state = %f,%f/%u\n", omp_get_thread_num(), i, x, y, state);

#endif

        if (x*x + y*y < 1) {

            hits++;

        }

    }

    printf("pi = %f (hits = %d)\n", (double)hits/LOOP_ITERATION * 4, hits);

    return 0;

}

$ gcc -o pi_monte_omp_logging -DLOOP_ITERATION=20 -fopenmp pi_monte.c

$ ./pi_monte_omp_logging

Loop iteration = 20

THR[0:0] x,y/state = 0.739258,0.373189/1534713604

THR[0:1] x,y/state = 0.741886,0.152093/434332526

THR[0:2] x,y/state = 0.399359,0.675170/1402811528

THR[0:3] x,y/state = 0.140991,0.510551/3217124562

THR[0:4] x,y/state = 0.117010,0.018486/2612351692

THR[0:5] x,y/state = 0.151627,0.286311/535820534

THR[0:6] x,y/state = 0.412198,0.450266/361487824

THR[0:7] x,y/state = 0.126866,0.324974/1313573850

THR[0:8] x,y/state = 0.923697,0.862684/1937324436

THR[0:9] x,y/state = 0.828232,0.810037/3167316350

THR[1:10] x,y/state = 0.739258,0.373189/1534713604

THR[1:11] x,y/state = 0.741886,0.152093/434332526

THR[1:12] x,y/state = 0.399359,0.675170/1402811528

THR[1:13] x,y/state = 0.140991,0.510551/3217124562

THR[1:14] x,y/state = 0.117010,0.018486/2612351692

THR[1:15] x,y/state = 0.151627,0.286311/535820534

THR[1:16] x,y/state = 0.412198,0.450266/361487824

THR[1:17] x,y/state = 0.126866,0.324974/1313573850

THR[1:18] x,y/state = 0.923697,0.862684/1937324436

THR[1:19] x,y/state = 0.828232,0.810037/3167316350

pi = 3.200000 (hits = 16)

#define _REENTRANT

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#ifdef LOOP_ITERATION

#define LOOP_ITERATION 200000000

#endif

int    hits;



int main()

{

    unsigned int state1, state2;

    int     i;

    double  x, y, rns;



    printf("Loop iteration = %ld\n", (long)LOOP_ITERATION);

    rns = 1.0/(double)RAND_MAX;

    state1 = (unsigned int)times(NULL);

#pragma omp parallel private(x, y, state2) reduction(+:hits) shared(state1)

    {

#pragma omp critical

        state2 = rand_r(&state1);

        printf("THR[%d] state1/state2 = %u/%u\n", omp_get_thread_num(), state1, state2);

#pragma omp for

        for (i=0; i<LOOP_ITERATION; i++) {

            x = (double)rand_r(&state2) * rns;

            y = (double)rand_r(&state2) * rns;

#if LOOP_ITERATION < 100

            printf("THR[%d:%d] x,y/state,hits = %f,%f/%u,%d\n", omp_get_thread_num(), i, x, y, state2,hits);

#endif

            if (x*x + y*y < 1) {

                hits++;

            }

        }

    }

    printf("hits(%d), pi = %f\n", hits, (double)hits/LOOP_ITERATION * 4);

    return 0;

}

$ gcc -o pi_monte_omp_logging -DLOOP_ITERATION=20 -fopenmp pi_monte.c

$ ./pi_monte_omp_logging

Loop iteration = 20

THR[0] state1/state2 = 2209777173/920556694

THR[0:0] x,y/state,hits = 0.007502,0.800638/402955376,0

THR[0:1] x,y/state,hits = 0.031584,0.366846/1879397754,1

THR[0:2] x,y/state,hits = 0.084310,0.126795/2318644788,2

THR[0:3] x,y/state,hits = 0.219188,0.054924/839319838,3

THR[0:4] x,y/state,hits = 0.315477,0.640078/2081973432,4

THR[0:5] x,y/state,hits = 0.423693,0.287051/4130577282,5

THR[0:6] x,y/state,hits = 0.738140,0.376765/2380434428,6

THR[0:7] x,y/state,hits = 0.127375,0.723816/3248220326,7

THR[0:8] x,y/state,hits = 0.832496,0.256793/3481063424,8

THR[0:9] x,y/state,hits = 0.939841,0.108509/3174395018,9

THR[1] state1/state2 = 2209777173/754906038

THR[1:10] x,y/state,hits = 0.446803,0.061819/2639594128,0

THR[1:11] x,y/state,hits = 0.919237,0.585474/2439875226,1

THR[1:12] x,y/state,hits = 0.122634,0.254468/2048737876,1

THR[1:13] x,y/state,hits = 0.204702,0.526382/3058641982,2

THR[1:14] x,y/state,hits = 0.642845,0.756832/477247192,3

THR[1:15] x,y/state,hits = 0.550340,0.531024/1736039586,4

THR[1:16] x,y/state,hits = 0.926036,0.217729/4074357788,5

THR[1:17] x,y/state,hits = 0.266219,0.975137/2510577606,6

THR[1:18] x,y/state,hits = 0.663719,0.557898/2880736800,6

THR[1:19] x,y/state,hits = 0.491536,0.580296/2760522154,7

hits(18), pi = 3.600000

$ gcc -o pi_monte_omp -fopenmp pi_monte.c

$ time ./pi_monte_omp

Loop iteration = 200000000

THR[0] state1/state2 = 319398670/265139008

THR[1] state1/state2 = 319398670/1387545353

hits(157082826), pi = 3.141657



real    0m2.414s

user    0m4.737s

sys 0m0.013s

#include <stdio.h>

#include <stdlib.h>

int num_steps=1000000000; /* 10억번 : 너무 많으면 조금 줄이시길... */



int main()

{

    int i;

    double x, step, sum = 0.0;

    step = 1.0/(double) num_steps;

    for (i=0; i<num_steps; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#define LOOP_ITERATION 200000000

int    hits;



int main()

{

    int 	i;

    double 	x, y, rns;

    time_t	t_now;



    printf("Loop iteration = %ld\n", (long)LOOP_ITERATION);

    rns = 1.0/(double)RAND_MAX;



    t_now = time(0);

    srand((unsigned int)t_now);

    for (i=0; i<LOOP_ITERATION; i++) {

        x = (double)rand() * rns;

        y = (double)rand() * rns;

        if (x*x + y*y < 1) {

            hits++;

        }

    }

    printf("pi = %f\n", 4*(double)hits/LOOP_ITERATION);

    return 0;

}

#define _XOPEN_SOURCE   600

#include <stdlib.h>

#include <unistd.h>

#include <stdio.h>

#include <time.h>

#include <sys/times.h>

#include <omp.h>

#ifndef LOOP_ITERATION

#define LOOP_ITERATION 200000000

#endif



double  pi[2];

int main()

{

    clock_t     start_m, end_m;

    clock_t     sc_clk_tck = sysconf(_SC_CLK_TCK);

    start_m = times(NULL);

    printf("LOOP ITERATION = %ld\n",(long)LOOP_ITERATION);

#ifdef _OPENMP

    omp_set_num_threads(2);

#endif

#pragma omp parallel

    {

#pragma omp sections

        {

#pragma omp section 

            {

                int     i;

                double  x, step, hits;

                float   t_elapsed;

                clock_t start, end;

                hits = 0.0;

#ifdef _OPENMP

                printf("[SECTION] integration method by thread(%d)\n", omp_get_thread_num());

#else

                printf("[SECTION] start integration method\n");

#endif

                start = times(NULL); /* get clock tick */

                step = 1.0/(double) LOOP_ITERATION;

                for (i=0; i<LOOP_ITERATION; i++) {

                    x = (i+0.5) * step;

                    hits += 1.0/(1.0 + x*x);

                }

                pi[0] = 4 * hits * step;

                end = times(NULL);

                t_elapsed = (float) (end - start)/sc_clk_tck;

#ifdef _OPENMP

                printf("[SECTION] end integration method by thread(%d):elapsed time(%.02f sec)\n", 

                        omp_get_thread_num(), t_elapsed);

#else

                printf("[SECTION] end integration method: elapsed time(%.02f sec)\n",

                        t_elapsed);

#endif

            }

#pragma omp section

            {

                int     i, state, hits;

                double  x, y, rns;

                float   t_elapsed;

                clock_t start, end;

#ifdef _OPENMP

                printf("[SECTION] monte carlo method by thread(%d)\n", omp_get_thread_num());

#else

                printf("[SECTION] start monte carlo method\n");

#endif

                start = times(NULL); /* get clock tick */

                state = time(0);

                rns = 1.0/(double)RAND_MAX;

                hits = 0;

                for (i=0; i<LOOP_ITERATION; i++) {

                    x = (double)rand_r((unsigned int *)&state) * rns;

                    y = (double)rand_r((unsigned int *)&state) * rns;

                    if (x*x + y*y < 1) {

                        hits++;

                    }

                }

                pi[1] = (hits / LOOP_ITERATION) * 4;

                end = times(NULL);

                t_elapsed = (float) (end - start)/sc_clk_tck;

#ifdef _OPENMP

                printf("[SECTION] end monte carlo method by thread(%d): elapsed time(%.02f sec)\n",

                        omp_get_thread_num(), t_elapsed);

#else

                printf("[SECTION] end monte carlo method: elapsed time(%.02f sec)\n",

                        t_elapsed);

#endif

            }

        }

    }

    end_m = times(NULL);

    printf("integration PI = %.8f\n", pi[0]);

    printf("monte carlo PI = %.8f\n", pi[1]);

    printf("* Total elapsed time(%.02f sec)\n", (double)(end_m - start_m)/sc_clk_tck);

    return EXIT_SUCCESS;

}

$ gcc -o pi_sections_omp -fopenmp pi_sections.c

$ time ./pi_sections_omp 

LOOP ITERATION = 200000000                                    

[SECTION] integration method by thread(0)                     

[SECTION] monte carlo method by thread(1)                     

[SECTION] end integration method by thread(0):elapsed time(1.79 sec)

[SECTION] end monte carlo method by thread(1): elapsed time(5.05 sec)

integration PI = 3.14159265                                          

monte carlo PI = 3.14161276                                          

* Total elapsed time(5.05 sec)                                       



real    0m5.052s

user    0m6.858s

sys     0m0.016s

• 지원언어 : C, C++, Fortran
• 표준 : http://www.openmp.org  (version 3.0 - May, 2008)

#pragma omp parallel [clause[ [, ]clause] ...] new-line

structured-block

# include <stdio.h>

int main() 

{

    printf("Hello world\n");

    return 0;

}

# include <stdio.h>

int main() 

{

#pragma omp parallel

    {

        printf("Hello world\n");

    }

    return 0;

}

• OpenMP 컴파일 옵션 : -fopenmp (GCC인 경우), -openmp (Intel C Compiler인 경우)
• 윈도우즈용 비주얼 스튜디오는 알아서 컴파일 해준다.

$ gcc -fopenmp -o helloworld_omp helloworld.c

$ ./helloworld_omp

Hello world

Hello world

# include <stdio.h>

# include <omp.h>

int main() 

{

    omp_set_num_threads(4);

#pragma omp parallel

    {

        printf("Hello world\n");

    }

    return 0;

}

• loop construct
• section construct
• single/master construct

$ gcc -fopenmp -o loop_exam1 loop_exam1.c

$ ./loop_exam1

[1-4] Hello world

[1-5] Hello world

[1-6] Hello world

[1-7] Hello world

[0-0] Hello world

[0-1] Hello world

[0-2] Hello world

[0-3] Hello world

#include <stdio.h>

#include <stdlib.h>

int num_steps=1000000000; /* 10억번 : 너무 많으면 조금 줄이시길... */



int main()

{

    int i;

    double x, step, sum = 0.0;

    step = 1.0/(double) num_steps;

    for (i=0; i<num_steps; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

$ make pi_numerical_integration

$ time ./pi_numerical_integration

PI = 3.14159265 (sum = 2513274122.87223005)



real    0m8.994s

user    0m8.993s

sys     0m0.001s

#include <stdio.h>

#include <stdlib.h>

int num_steps=1000000000; /* 10억번 : 너무 많으면 조금 줄이시길... */



int main()

{

    int i;

    double x, step, sum = 0.0;

    step = 1.0/(double) num_steps;

#pragma omp parallel for

    for (i=0; i<num_steps; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

$ make CFLAGS="-fopenmp" pi_numerical_integration

$ time ./pi_numerical_integration

PI = 2.26234349 (sum = 1809874795.18165779)



real    0m50.394s

user    1m38.686s

sys     0m0.013s

#include <stdio.h>

#include <stdlib.h>

int num_steps=1000000000; /* 10억번 : 너무 많으면 조금 줄이시길... */



int main()

{

    int i;

    double x, step, sum = 0.0;

    step = 1.0/(double) num_steps;

#pragma omp parallel for private(x) reduction(+:sum)

    for (i=0; i<num_steps; i++) {

        x = (i+0.5) * step;

        sum += 4.0/(1.0 + x*x);

    }

    printf("PI = %.8f (sum = %.8f)\n", step*sum, sum);

    return EXIT_SUCCESS;

}

• schedule(static [, x])
• schedule(dynamic [, x])
• schedule(guided [, x])

# svcs

STATE          STIME       FMRI

lagacy_run     12:51:42    lrc:/etc/rcS_d/S50sk98sol

... (생략)

online         12:51:49    svc:/network/inetd:default

# svcs | grep ftp

online                  12:51:49       svc:/network/ftp:default

# svcs -l ftp

fmri     svc:/network/ftp:default

이름    FTP server

사용    참

상태    online

...

# svcs -x

svc:/application/print/server:default (LP print server)

상태: disabled(2005년 10월 17일 월요일 오후 12시 51분 36초 이후)

이유: 관리자가 비활성화했습니다.

   참조: http://sun.com/msg/SMF-8000-05

   참조: lpsched(1M)

영향: 2개의 종속 서비스가실행되지 않습니다.  (목록을 보려면 -v 사용)

# svcadm

사용법: svcadm [-v] [cmd [args ... ]}



        svcadm enable [-rst] <서비스> ...       - 서비스를 활성화하고 온라인으로 설정함

        svcadm disable [-st] <서비스> ...       - 서비스를 비활성화하고 오프라인으로 설정함

        svcadm restart <서비스> ...             - 지정한 서비스를 다시 시작함

        svcadm refresh <서비스> ...             - 서비스 구성을 다시 읽음

        svcadm mark [-It] <상태> <서비스> ...   - 유지 보수 상태로 설정함

        svcadm clear <서비스> ...               - 유지 보수 상태를 해제함

        svcadm milestone [-d] <이정표>  - 서비스 이정표로 진행함



        서비스는 FMRI, 약어 또는 fnmatch(5) 패턴을 사용하여 지정할 수 있습니다.

        svc:/network/smtp:sendmail에 대한 다음 예를 참조하십시오.



        svcadm  svc:/network/smtp:sendmail

        svcadm  network/smtp:sendmail

        svcadm  network/*mail

        svcadm  network/smtp

        svcadm  smtp:sendmail

        svcadm  smtp

        svcadm  sendmail

# svcadm restart svc:/network/ftp:default

# svccfg

svc:> list

system/console-login

...

network/rpc-100068_2-5/rpc_udp

network/ftp/tcp

svc:> select ftp

:properties

default

svc:/network/ftp> listprop

general                        framework

general/entity_stability       astring  Unstable

general/restarter              fmri     svc:/network/inetd:default

inetd                          framework

svc:/network/ftp> editprop

...

svc:/network/ftp> select default

svc:/network/ftp:default> listprop 

general                    framework

general/enabled            boolean  true

inetd_start                framework

inetd_start/exec           astring  "/usr/sbin/in.ftpd -l"

svc:/network/ftp:default> end

# inetadm

ENABLED   STATE          FMRI

enabled   online         svc:/network/rpc/mdcomm:default

...(생략)...

enabled   online         svc:/network/rpc-100068_2-5/rpc_udp:default

disabled  disabled       svc:/network/ftp/tcp:default

# inetadm -?

사용법:

  inetadm

  inetadm -?

  inetadm -p

  inetadm -l {FMRI | 패턴}...

  inetadm -e {FMRI | 패턴}...

  inetadm -d {FMRI | 패턴}...

  inetadm -m {FMRI | 패턴}... {name=value}...

  inetadm -M {name=value}...

# inetadm -l svc:/network/ftp:default

SCOPE    NAME=VALUE

         name="ftp"

         endpoint_type="stream" 

         proto="tcp"

         isrpc=FALSE

         wait=FALSE

         exec="/usr/sbin/in.ftpd -l"

         user="root"

default  bind_addr=""

default  bind_fail_max=-1

default  bind_fail_interval=-1

default  max_con_rate=-1

default  max_copies=-1

default  con_rate_offline=-1

default  failrate_cnt=40

default  failrate_interval=60

default  inherit_env=TRUE

default  tcp_trace=FALSE

default  tcp_wrappers=FALSE

# inetadm -m svc:/network/ftp:default max_copies=20

# inetadm -l svc:/network/ftp:default

SCOPE    NAME=VALUE

         name="ftp"

         endpoint_type="stream"

         proto="tcp"

         isrpc=FALSE

         wait=FALSE

         exec="/usr/sbin/in.ftpd -l"

         user="root"

default  bind_addr=""

default  bind_fail_max=-1

default  bind_fail_interval=-1

default  max_con_rate=-1

         max_copies=20

default  con_rate_offline=-1

default  failrate_cnt=40

default  failrate_interval=60

default  inherit_env=TRUE

default  tcp_trace=FALSE

default  tcp_wrappers=FALSE