2015-12-30

일상. 하루의 기나김


직장을 다녀며 나름 치열하게 대학원을 졸업 하고도
이제는 잊을 만큼 긴 시간이 흘렀다.

나의 일에 집사람 일에 , 태어난 아기의 일까지..
나의 일도 중요하고, 다른 사람의 일도 중요하고, 가족의 일도 중요하고

시간이 없다, 시간이 없다, 역시 시간은 비싸다.

역사와 문화를 통틀어 시간은 가장 귀한 가치임에 틀림 없다.
누구나에게나 주어진 가장 동등하고 공평, 평등한 자원..
이는 그 이상의 가치가 있을 것이다.

물론, 과학적으로 시간의 절대성이 사라진 이 시대에는 어찌 보면 역설적이지만
미시적 세계에 지나지 않는 세상에서는 그 의미가 충분할 것이다.

여튼, 긴 시간 동안, 내게 주어진 최상의 가치를 지키기 위해 나름대로 치열하게 살아 왔다고 다짐해 보며, 하루 1시간이라도 시간의 부족에 대해 얘기해 왔었는데 ..
근 1,2개월 새벽 5시에 일어나 출근전까지 약 2시간 반에서 3시간정도 독서를 할 시간을 갖을수 있게 되었음을 볼때..

시간의 부족이 아니라 , 어쩌면 나의 부족일수 있겠구나라는 생각이 들었다.

깨어 있는자만의 기회를 볼수 있을것이며,
준비된 자만이 기회를 잡을수 있을것이다.


새벽, 부족한 잠을 깨우고, 눈을 부비며 일어 나는 시간, 그 시간 아침의 고요가
얼마나 가치 있으며 소중하고, 평온한지.
다시 스스로를 깨울 시기다.

2015-12-29

IT 기술사 토픽 마인트 맵 정리 - 1차

IT 기술사 토픽   마인트 맵 정리 - 1차
  • 2차 수행 작업 예정

  1. 각 영역별 관계 정의
  2. 각 토픽간의 관계 영역 정리
  3. 각 영역, 토픽간 입체적인 관계 정의 
  4. SW공학 영역 토픽 맵 추가 




운영체제 ( Operating System )


IT 기업 경영 ( Enterprise Solution )

네트워크 ( Network )

컴퓨터 구조 ( Computer Structure )

정보보호( IT Security )

2015-12-22

어니스트 해밍웨이 - 단편선- 킬리만자로의눈

어니스트 해밍웨이 - 단편선- 킬리만자로의눈

 : 8
잘 모르지만, 헤밍웨이가 니힐리즘에 빠져 있었다고 하고, 
자잘한 수식이 아닌 빠르고 간결한 문장으로 꼭 필요한 문장만으로 글을 쓴다고 하고 있다.

자기 말로는 꼭 필요한 문장만으로 쓸수 없다고 글이 아니다 라는 식의 뉘앙스로 글을 말을 했다고 하는데, 글과 문학 이란것이 단순히 시대와 정보를 담는것만이 아닌이상 저리 딱딱한 문장만 쓸것 같은 표현은 안해도 됐지 않을까 싶다.

하지만 글을 읽어 보면 정말 단순한 문장의 연속으로 되어있다.
예를 들면 "했다", "그랬다",'말했다" 다다다다다.... 로 문장이 이루어져 있어서,
마치 초벌번역한 어색한 번역채 같아서 처음엔 보기 힘들다.

단편집을 중반이상 읽어야만  조금 익숙해졌고, 그 문장안에서 저자가 정하고자 했던 , 허무함이라던지, 유물론적 사고관 이라던지, 작중 인물의 감정같은게 조금 느껴지기 시작했다.

단편집중 좋았던 작품은
1. "깨끗하고 불이 환한곳",
2. "킬리만자로의 눈",
3. "두개의 심장을 가진 강"
순이 었다.

누구는 섬세하다고, 세밀하다고도 하는데 잘 모르겠고,
 그의 작품중 백미인 " 노인과 바다" 를 제대로 읽어 봐야 겠다.

Centos7 이더넷 어댑터 eno* 이름 변경하기

Centos7 이더넷 어댑터 eno* 이름 변경하기



Centos7 은 일반적으로 전버전의 Centos와는 다르게 이더넷 인터페이스의 이름이 eth*의 순으로 이름 붙여지지 않고, eno**로 이름이 붙여 진다.

뒤에 일련번호가 붙는데 외우기 어렵고 , 다른 이더넷 인터페이스와 같이 표시되면 구분하기가 사실상 쉽지 않다.

이 이름을 사용자 편의에 맞추기 위해서는 사용자 디바이스를 설정해야만 한다.
다음의 파일을 열어 수정한다.

/etc/udev/rules.d/70-persistent-ipoib.rules

수정/ 혹은 추가할 내용
* centos에는 udev에 추가한 이더넷 인터페이스가 없어서 , 처음에도 추가 해줘야 한다.
붉게 체크된 부분을 변경한다.
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="00:0C:29:F1:A6:A6", ATTR{dev_id}=="0x0", ATTR{type}=="1", KERNEL=="eno16777736", NAME="public"


실제 서버의 네트워크 환경에 적용하기 위해서는, 밑에 파일을 udev에서 지정한 설정에 맞게 맞추어 준후 네트워크 서비스를 재시작한다.
# cat /etc/sysconfig/network-scripts/ifcfg-public TYPE=Ethernet BOOTPROTO=none DEFROUTE=yes IPV4_FAILURE_FATAL=no IPV6INIT=yes IPV6_AUTOCONF=yes IPV6_DEFROUTE=yes IPV6_FAILURE_FATAL=no NAME=public UUID=1d9eb6ce-ffb1-4720-bcde-093397d1010e DEVICE=public ONBOOT=yes DNS1=10.10.0.3 DNS2=10.10.0.4 HWADDR=00:0C:29:F1:A6:A6 IPADDR=10.10.15.11 PREFIX=8 GATEWAY=10.10.0.1 IPV6_PEERDNS=yes IPV6_PEERROUTES=yes



2015-12-21

Centos7 더블클릭으로 쉘 스크립트 실행하는법

Centos7 더블클릭으로 쉘 스크립트 실행하는법


Centos 의 버전7 부터는 버전 6 과는 다르게
, 스크립트를 더블클릭 해도 스크립트를 바로 실행하지 않고 별도의 어플리케이션으로 연결된다.

더블클릭으로 쉘 스크립트를 실행하기 위해서는 바탕화면에 *.desktop 파일을 생성한다.

gedit 혹은 vi로 열어서 다음과 같이 수정한다.


#!/usr/bin/env xdg-open [Desktop Entry] Name=SmartGit Comment=Git launcher Exec=/develop/smartgit/bin/smartgit.sh <--- 더블클릭으로 실행할 스크립트를 지정. Icon=/develop/smartgit/bin/smartgit-32.png Terminal=false Type=Application
저장후, 바탕화면에 생성된 파일과 그 속성을 보면 다음과 같다.



이제 해당 파일을 더블클릭하면 , 바로 쉘 스크립트를 실행하게 된다.

2015-12-14

아이와 함께 그리기

아기와 함께 그리다 보면,
대상을 그리기 위해 그리는것 보다, 그리고 나서 대상을 찾게된다.
긋다보니 다리 달린 미꾸라지

지르다 보니, 산


돌리다 보니 달팽이

2015-12-07

2015-12-03

이클립스 원격 디버깅

이클립스  원격 디버깅


해당 제품 밑 eclipse.ini 파일을 열어 조작 한다.

-vmargs  밑줄에

다음 구문을 추가한다.




-Xdebug
-Xnoagent
-Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=y


suspend=y에 'n'을 지정하면, 클라이언트가 접속하지 않아도 , 서버쪽을 정상 가동 시킬수 있다.

제품이나 이클립스의 재기동후,
원격이로 접속할 클라이언트 이클립스를 설정한다.



1) 이클립스의 RUN>> Debug Configuration 을 선택한다.



2) 디버깅할 서버쪽 설정을 입력한다.
Project : 디버깅할 소스 프로젝트 지정
Host : 디버깅할 서버쪽 주소 입력
Port : 디버깅할 서버쪽 포트 입력


3) 브레이크 포인트 지정클라이언트쪽 브레이크 포인트를 지정하면, 원격지 서버가 동작중에 해당 프레이크 포인트 지점 수행시 , 해당 시점의 데이터를 확인 할수 있다.





2015-11-26

대용량 데이터 베이스 솔루션 I - 시스템의 진단과 튜닝

대용량 데이터 베이스 솔루션 I        

Ch4. 시스템의 진단과 튜닝.                                                                                                            

  > MONITOR 다양한 시스템활동과,그통계정보를  모니터 할 수 있는 SQL*DBA 기능 .                                                                                                         
  > SQL_TRACE 수행된 각종 SQL의 결과를 TRACE 파일로 출력해주는 기능.                                                                                                         
  > TKPROF 트레이스 파일을 이용해서 실행계획과 그출력을 해주는 기능.                                                                                                         
  > EXPLAIN PLAN SQL을 분석해서 실행계획을 수립한후 유저를 위해 Plan_TABLe에 저장 하도록 해주는 명령어.                                                                                                         
  > ANALYZE 비용기준 (COST-BASED) 옵티마이져 가  최소 비용을 가지는 수행경로를 수립하기윈한 각종 통계정보를 컴파일하는 명령어.                                                                                                         
  > UTLBSTAT(begin) 과 UTLESTAT(end) 데이터 베이스에 대한 실행상태에 대한 통계정보를 보여주는 스냅샷을 생성해주는 SQL SCRIPT 들.                                                                                                         
  > 기타 스크립트들 오라클에 제공해 주는 추가적인 진단과 튜닝 스크립트들.                                                                                                          
  > 사용자 스크립트들  사용자가 직접만든 진단과 튠닝 스크립트들.                                                                                                          
  > SQL area 튜닝  SQL 공휴율(hit ratio)을 향상 시키고 메모리 활용을 위해 적용하는 투닝 방법들.                                                                                                         
  > 병렬처리 튜닝  만읗양의 데이타의경우 효과적으로 병렬처리를 효율화 시키기 위한 튜닝 방법들.                                                                                                         
                                                                                                           
  > MONITOR ( 시스템 활동감시)                                                                                                         
     >> SQL*DBA MONITOR기능은 플랫폼에 따라 사용방법은 조금씩 틀리지만 그 기능은 동일하다.                                                                                                      
     >> SYSTEM 또는 INTENAL  유저 그룹에서 로그인해야 사용할수있다.                                                                                                      
  %     > MON FILEIO                                                                                                          
        > MON CYCLE number                                                                                                      
                                                                                                           
  > SQL_TRACE (TRACE 파일 생성)                                                                                                         
     >> SQL 파싱 ,샐행, 펫치를 수행한 횟수                                                                                                       
     >> 수행한 CPU 시간과 경과한 시간                                                                                                       
     >> 물리적, 논리적 인  읽기를 수행한 횟수                                                                                                       
     >> 추출된 로우싀 수                                                                                                       
     >> 유용한 정보를 제공하지만  SQL_TRACE 를 수행시키면 성능은 20%~30% 감소하게 된다.                                                                                                      
     >> SQL_TRACE 파라미터 들.                                                                                                      
        >>> TIMED_STATISTICS  = TRUE      RDBMS 가 SQL 실행에 대한 추가적인 시간 통계정보를  표시하게한다.                                                                                                   
        >>> SQL_TRACE = TRUE    SQL_TRACE 오라클 에세션을 갖는 모든 사용자의 트레이스를 수행한다.                                                                                                   
        >>> USER_DUMP_DEST       TRACE 파일이 생성되는 경로를 지정한다.                                                                                                   
        >>> MAX_DUMP_FILE_DEST  SQL_TRACE 파일의 크기                                                                                                   
                                                                                                           
  %  SQL>@D:\oracle\ora92\rdbms\admin\utlxplan.sql                                                                                                         
     SET AUTOTRACE ON;                                                                                                      
     SHOW PARAMETER USER_DUMP_DEST;                                                                                                      
     ALTER SESSION SET SQL_TRACE= TRUE;                                                                                                      
     ALTER SYSTEM SET USER_DUMP_DEST ='d:\sqltrace' scope=both;                                                                                                      
     ALTER system SET max_dump_file_size  = 10000 scope=both;                                                                                                      
     ALTER SYSTEM SET timed_statistics=TRUE scope=both;                                                                                                      
                                                                                                           
  > TKPROF                                                                                                          
        분석법                                                                                                   
                                                                                                           
               
                             만약 I/O병목 현상 때문이라면 과련된 테이블을 여러 개의 디스크에 분할 해 병목 현상을 해결해야 한다.                                                                              
                                                                                                           
     >> TRACE 파일의 데일 끝에 나오는  OVERALL TOTALS FOR ALL NON-RECURISIVE STATEMENTS 에대한 분석                                                                                                      
                                                                                                           
                                   
        >>> Parse 라인에 있는 CPU ,ELASPED, DISK 항목의 값이 EXCUTE 나 FETCH 라인의 값에 비해 비교적높으면  메모리 내의 자료사전 정보를 더 저장                                                                                                    
           할수 있도록 자료사전 캐쉬를 튜닝해야 한다. (시스템이 자동적으로 조절하므로 , sql 공유 역역을 늘려줌으로 해결한다.)                                                                                                
        >>> Parse 의 COUNT 값이 높으면 애플리케이션이 정반적으로 많은 SQL 을 반복 수행 했다는 것이 된다,  보관커서를 사용해서 효율을 높이거나                                                                                                    
           SQL 자체를 튜닝해야한다.                                                                                                
        >>>( Excute의 disk + fetch의 disk )의 값이( Excute의 query + Excute의 current +fetch 의 query + fetch의 current )의 10%이상이라면                                                                                                    
           메모리의 hit ratio 가 너무 낮은 것이므로 SQL database buffer cache 를 늘려주어야 한다.                                                                                                
        >>> Pl/SQL 을 사용한 경우에  fetch의 count 가  fetch 의 rows 보다 두배 가까이 커진다면  내부에서 내부 커서가 사용되고 있을 확률이 높다.                                                                                                   
           즉  declare 한 sql한 문장이 실행되 한번씩 fetch 될때마다 SELECT .. INTO  가 수행되고 있다는 것을 의미하므로  declare 된 SQL 에서 join을 해                                                                                                 
           FETCH ..INTO 의 형태가 되게 하거나 반복수행되는 SQL 들을 모아서 조인을 해주어 해결한다.                                                                                                
                                                                                                           
        >>> 다음은 아주빠른 응답 시간이 요구되는 온라인 프로세싱 시스템의 경우에서만 적용되는 규칙들이다.                                                                                                   
              >>>> 모든 Excute 의 cpu 가 1초보다 적어야 한다.                                                                                             
              >>>> parse cpu 시간이 parse 당  0.01초 보다 적어야 한다.                                                                                             
              >>>> 작은 테이블에서만 전체 테이블 스캔이 일어나게 한다 , 약 200 로우 이상인 테이블과 여러 테이블을 조인할때 많이 쓰이는 테이블은 전체                                                                                              
                 테이블을 스캔하지 않도록 해야한다.                                                                                          
              >>>> sysdate 만 찾아 오거나 연산만 하거나 select .. Into 로 값을 복사하는 경우를 위해 여미 테이블을 불필요하게 사용하는것은 모두 없애                                                                                              
                 주어야 한다.                                                                                          
              >>>> 동시에 작업되는 sql 들은 가능한 pl/sql 을 사용하는것이 좋다.                                                                                             
              >>>> 조인시에 옵티마이져가 적절한 드라이빙 테이블을 선택하는지 확인하거나 처리범위와 분포도에 따라 인덱스를 변경 해주어야 한다.                                                                                             
                                                                                                           
  > EXPLAIN PLAN (실행계획 )                                                                                                         
                                                                      
                                                                                                           
     >>ANALYZE (통계정보 생성)                                                                                                      
        >>> ANALYZE 는 인덱스 테이블 클러스터의 통계정보를 생성하여 옵티마이저가 가장 효율적인 실행계획을 세울수 있도록 도와준다.                                                                                                   
           >>>> COMPUTE 레벨 느리지만 정확한 통계값을 계산해낸다.                                                                                                
           >>>> ESTIMATE 레벨 자료사전과 견본테이자를 가지고 통계를 산출한다.                                                                                                
           >>>> DELETE 테이블의 모든 통계정보를 삭제한다.                                                                                                
        >>> 산출되는 통계 데이터                                                                                                    
            >>>> 테이블             총로우의수,총블럭의수,비어있는 블록에 쓰여질수있는 빈공간의평균, 체인이발생한로우의 수 , 로우의 평균 길이                                                                                    
           >>>> 인덱스              인덱스의 깊이,LEAF block 의 수 , DISTINCT KEY 의 수 , LEAF BLOCKs/KEY 의 평균                                                                                    
                       DATA BLOCK/KEY 의 평균, CLUSTERING FACTOR , 가장 크고,가장 작은  KEY 값 (compute 만)                                                                                    
           >>>> 컬럼             distinct 한 값의수                                                                                     
           >>>> 클러스터             CLUSTER KEY 당 길이의 평균                                                                                    
                                                                                                           
     >> 실행계획을 위한 지침 사항                                                                                                       
        >>> 주기적인 ANALYZE 작업을 수행시켜야 한다.                                                                                                   
        >>> 액세스 경로가 자주 바뀌면  APP 의 SQL을 추출하여 액세스 경로를 고정시킬 필요가 있다.                                                                                                   
        >>> 총로우수가 많은 테이블은 ANALYZE 가 부담이 되므로 가능한 작업 주기를 길게하고,부담이 크다면 인덱스를 재구성한다.                                                                                                   
        >>> 테이블을 재생성 하였거나 , 새로 클러스터링을 한경우 는 작업 주기에 상관없이 ANALYZE를 수행 시켜주는 것이 좋다.                                                                                                   
                                                                                                           
     >> UTLTSTAT.sql        UTLESTAT.sql                                                                                                      
        위의 두 스크립트는 데이터 베이스가 일정 기간 동안 실행되고 있는 상태를 알려주는 스냅샷을 생성한다 이를 보면 튜닝할 대상과                                                                                                    
        발생한 문제점을 알수있다.                                                                                                   
        >>> UTLBSTAT.SQL은 테이블에 통계정보를 쓰기 시작하라고 DBMS에 알림.                                                                                                   
        >>> UTLESTAT.SQL은 쓰기작업을 멈추고 리포트를 보여주는 스크립트이다.                                                                                                   
        >>> 단 사용자가 없을 시간대에 적용시키면 비현실적인 판단이 도출되므로 오전 10시에서 정오까지, 오후2시오후4시,를 실행시킨다.                                                                                                   
        >>> 여기서도 TIMED_STATISTICS 를 TRUE 로 한다. 해야 자세한 시간 통계정보를 얻을수있다.                                                                                                   
  %   SQL>@UTLBSTAT                                                                                                      
                                                                                                           
      SELECT n1.name "statistic" , n1.change "total" , trunc (n1.change /n2.change,2) "per trans"                                                                                                      
           FROM stats$stats n1 , stats$stats n2                                                                                                
              WHERE n2.name = 'user commits'                                                                                              
                 ORDER BY n1.name;                                                                                          
                               
                                                                                                           
        >>> ①에서Enqueue waits > 0 이면  INIT.ora 파일의 ENQUEUE_RESOURCE  파라메터의 값을 증가시켜야 한다.                                                                                                   
        >>> ② Recursive calls / user call   의 값이 0.1 보다 크면 딕셔너리 캐쉬 가 부족하다는 것을 의미하므로 SQL 공유 영역을 증가시켜야 한다.                                                                                                   
        >>> ③위의 세가지 SORT 통계는 SORT_AREA_SIZE 와 SORT_AREA_RETAINED_SIZE 의 값을 증가시켜야 할것인지를 판단하는데 사용한다.                                                                                                   
                                                                                                           
        >>> 메모리 버퍼 캐쉬 적중률 (buffer cache hit ratio ) 튜닝                                                                                                   
           이튜닝은 디스크의 I/o를 줄이고 메모리에서 최대한의 데이터를 액세스 하기위한 것이다. BUFFER  CACHE의 효율을 높이면 DB의 성늘을 탁월하게                                                                                                 
           높일수 있다 정중률 100%를 목표로 한다.                                                                                                
                                         이 결과 값이 90%보다 적으면 공유영역에 대한 튜닝이 되어야 하고,사용자가                                              
                                   physical read                            가장 많이 사용할때 버퍼의 영역이 5%남아 남을때까지 버퍼의 값을 늘려야 한다.                                             
                                                                                                           
              INIT.ORA 파일의 DB_BLOCK_BUFFERS 를 증가하거나 감소시킨후 DBMS를 재가동 시킨다 , 그러나 메모리 5%정도는 꼭 남겨둬야 한다.                                                                                             
                                                                                                           
        >>> 버퍼 캐쉬의 튜닝(buffer cache)                                                                                                   
           버퍼캐쉬는 테이블 , 인덱스 , 롤백 세그먼트, 클러스터 들의  데이터 베이스 블록에 대한 복사본을 저장하는 메모리 영역이다.  버퍼 캐쉬는 디스크 I/O를 현저히                                                                                                
           줄여주고 효율을 향상시킨다.  INIT.ORA 파라메터의 DB_BLOCK_BUFFER 값을 증가 시키면  오랫동안 수행되는 갱신(UPDATE)작업등은 경우에 따라 50%이상의                                                                                                 
           효율 향상을 가질수있다.                                                                                                 
           >>>> 버퍼 캐쉬 증가후에 나타날 캐쉬적중의 효과를 측정하려면  INIT.ORA 파일의  DB_BLOCK_LRU_EXTENDED_STATISTICS 파라메터에 원하는 버퍼 캐쉬                                                                                                 
                 증가치를 지정한다. 예를 들어 1000 을 지정하고 250마다 증가시킨 효과를 보기위해서는                                                                                          
  %    SELECT 250*TRUNC(INDX/250)+1 || 'to' || 250*(TRUNC(INDX/250)+1) INTERVAL, SUM(COUNT) CACHE_HITS                                                                                                         
        FROM SYS.X$KCBRBH                                                                                                   
        GROUP BY TRUNC(INDX/250);                                                                                                   
                                                                                                           
     결과          INTERVAL             CACHE_HITS                                                                                    
           1 to 250            21000                                                                                    
           251 to 500            15000                                                                                    
           501 to 750            3000                                                                                    
           751 to 1000            35000                                                                                    
                                                                                                           
           >>>> 버퍼 캐쉬를 감소 시켰을 때의 측정결과                                                                                                
  %    SELECT 250*TRUNC(INDX/250)+1 || 'to' || 250*(TRUNC(INDX/250)+1) INTERVAL, SUM(COUNT) CACHE_HITS                                                                                                         
        FROM SYS.X$KCBRBH                                                                                                   
        WHERE INDX > 0                                                                                                   
        GROUP BY TRUNC(INDX/250);                                                                                                   
                                                                                                           
        >>> 롤백 세그먼트와 오라클 데이터블럭간의 경합을 줄이는 튜닝                                                                                                   
           >>>> UTLBSTAT/UTLESTAT의 통계를 사용하여 다음과 같은 방버븡로 계산한다.                                                                                                
              BUFFER Busy waits ratio = (buffer busy waits) / (logical reads)                                                                                             
                              = (1) /39414 = 0.00002                                                                              
              계산 결과가 0이 아니면 블록 경합이 발생하는것을 가르킨다. 만약 0.05 이상이면 상태가 안좋은 것임,                                                                                              
              결과가 0.05~ 0.1 이라면  V$WAITSTAT 를 조회하여 (TIMED_STAISTICS=TRUE) Undo Block 과  undo egment Header 이 기다리는 시간이 많으면                                                                                              
              롤백 세그먼트 더 많이 생성해야 하며 Data block 과 segment header 항목에 기다리는 시간이 많다면  프리 리스트를 더욱 크게 생성 해야 한다.                                                                                             
                                                                                                           
        >>> DBWR의 튜닝                                                                                                    
           >>>> UTLBSTAT/UTLESTAT의 통계중 DBWR free needed 가 0이 아니면 당장 개선해야한다.                                                                                                 
              >>>>> INIT.ORA 파일의 DB_WRITER 와 _DB_BLCOK_WRITE_BATCH 의 값을 증가시켜 버퍼수를 늘려 쓰기 작업의  효율을 늘린다.                                                                                             
           >>>> DBWR Checkpoints DBWRdp 보내진 CHECK POINT 의 수이다 ,체크 포인트의 주기가 길어지면 대개의 경우 성능은 향상되지만 복구에는 약해지게 된다.                                                                                                
              >>>>> 체크포인트수를 줄이려면 INIT.ORA 에서 LOG_CHECKPOINT_INTERVAL 값을 증가시킨다.                                                                                             
           >>>>  LOG_CHECKPOINT_TIMEOUT 다음 체크 포인트까지의 시간을 지정한다 0이면 사용불가설정이된다.                                                                                                
           >>>> DBWR make free requests DBWR 가 LRU 를 위해서 사용가능버퍼를 더 만들도록 요구하는 메시지를 받은 횟수.                                                                                                
           >>>>. DBWR free buffer found 사용가능버퍼에대한 요구에대해서 찾은 사용가능한 버퍼수이다,  DBWR make free request 와 나우어서 LRU 이후 다시                                                                                                
              사용할수 있는 평균버퍼정도를 알아낸다.                                                                                             
           >>>> DBWR lru scans DBWR 가 더 많은 사용가능 버퍼르 요구하기 위해 LRU 를 스캔한 수이다.                                                                                                
           >>>> DBWR summed scan depth DBWR 가 변경버퍼(dirty buffer)를 찾기위해 스캔할때마다 현재의 스캔깊이가 이 통계에 더해진다.                                                                                                
           >>>> DBWR buffers scans 변경된 버퍼를 처리하기위해 LRU를 스캔한 버퍼의수 .                                                                                                
           >>>> summed dirty queue length 모둔 쓰기 요구가 끝난뒤 LRU 큐 길이의 합. Write requests 와 나누어서 평균 큐의 길이를 구할수 있다.                                                                                                
           >>>>  free buffer inspected 사용자 프로세스가 버퍼 를 필요로 했을때 버퍼 캐쉬를 초과한 수이다. 이값이 free buffer scans 와 비교해 높다면                                                                                                
                 버퍼캐쉬에 너무 많은 변경 블록이 있다는것이므로  버퍼 캐쉬의 크기를 증가시켜야 한다.                                                                                          
           >>>> free buffe waits 프로세스가 사용가능 버퍼를 찾지못해 기다림이 발생한 횟수이다.  Free buffer waits / free buffer scans dl 10% 보다크면                                                                                                 
                 init .ora 에  _DB_BLOCK_WRITE_BATCH 를 증가 시켜야 한다.                                                                                          
                                                                                                           
        >>> 액세스 방법의 튜닝                                                                                                    
           인덱스를 이용한 데이터 액세스의 효율성을 확인한다.                                                                                                
            tables scans (long tables) / (table scans(short tables) + table scans (long tables)) 가 10% 보다 크면 인덱스의 활용에 대해 다시 검토해본다.                                                                                                
                                                                                                           
        >>> I/O 분포의 튜닝                                                                                                    
           UTLBSTAT/UTLESTAT temporary table 를 조회하여 본다.                                                                                                
  %   SELECT * FROM STATS$FILES;                                                                                                         
           위이 쿼리의 결과를 토대로 가장 활종적인 차일을 찾는다 만약 SYSTEM 이가장 활동적이라면 좋은것이 아니다 TEMP가 활동하지 않으면 사용자 그룹별로                                                                                                 
           TEMP 가 지정이 되어있지 않기 때문이므로 지정해준다.                                                                                                 
  % ALTER USER username TEMPORARY TABLESPACE tablespacename;                                                                                                         
           를 사용해 각사용자에게 TEMP 테이블 스패이스를 할당한다.                                                                                                
                                                                                                           
        >>> 데이터 파일별 디스크 I/O 튜닝                                                                                                    
  % SELECT NAME, PHYRDS,PHYWRTS                                                                                                          
        FROM V$DATAFILE DF , V$FILESTAT FS                                                                                                   
           WHERE DF.FILE# = FS.FILE#;                                                                                                
           시스템 테이블 스패이스에 부하가 걸릴경우 자료사전의 참조를 하는 파싱을 줄여주는 SQL 을 사용하거나 정렬작업이 있어나는 곳을 TEMPORARY 로                                                                                                 
           바꾸어준다.                                                                                                
                                                                                                           
        >>> SORT duddur 증가에 의한 I/O 감소                                                                                                    
           SQL 문장에 GROUP BY, ORDER BY, DISTINCT 를 사용했거나 소트 머지 조인,집합처리,,인덱스 생성  서브 쿼리를 하는 SQL 문은 처리과저에서                                                                                                 
           로우의 정렬이 필요하다                                                                                                
  % SELECT NAME, VALUE FROM V$SYSSTAT                                                                                                         
        WHERE NAME IN('sorts(disk)','sorts(memory)','sorts(rows)');                                                                                                   
                                                                                                           
        결과    sorts(disk)            543                                                                                    
           sorts(memory)            587318                                                                                    
           sorts(rows)            11268045                                                                                    
                                                                                                           
           >>>> sorts(disk) 는 INIT.ORA 의 SORT_AREA_RETAINED_SIZE 로 지정된블럭보다 정렬되는 데이터가 필요할때 TEMPORARY SEGMENT를 생성하                                                                                                
                 므로 발생한다. 디스크 와 메모리 정렬은 전체의 5%미만이 적당하다, 아니면 SORT_AREA_SIZE 를 증가시킨다.                                                                                          
                 SORT_AREA_RETAINED_SIZE 를 1M , SORT_AREA_SIZE 를 10M 로 지정했을떄                                                                                           
                    >>>>> 1M 이내의 SORT는 디스크와 관계 없이 메모리 에서 정렬한다.                                                                                       
                    >>>>> 1M~10M의 SORT 는 SORT_AREA_SIZE를 넘지 않으므로 단한번의 메모래내 정렬작업으로 완료한다. 그러나                                                                                        
                          SORT_ZREA_RETAINED_SIZE 를 넘었기때문에 정렬한 결과를 즉시 디스크에 쓰고 메모리에서 지운다.                                                                                 
                    >>>>> 10M이상의 SORT 는 두가지 파라미터를 모두 넘으므로 SORT_AREA_SIZE 만큼만 메모리 작업을 하여 디스크에 쓰는 방식을 반복한다.                                                                                       
                    >>>>> 대용량 OLTP의 처리가 있는 경우에는 SORT_AREA_SIZE 를 일시적으로 증사시키고 작업이 종료하면 다시 줄이는 것도 좋은 방법이다.                                                                                       
           >>>>다양한 정렬작업을 위해 , 임시 테이블 스패이스의 STORAGE 값을 이용, 사용시간에따라 조정해준다.                                                                                                
              >>>> 온라인 작업이 많은 낮시간대에는..                                                                                             
  %    ALTER TABLESPACE TEMP_TSPACE DEFAULT STORAGE (INITIAL 260K NEXT 260K PCTINCREASE 0);                                                                                                         
              >>>> 배치 작업이 많은  밤에는                                                                                              
  %    ALTER TABLESPACE TEMP_TSPACE DEFAULT STORAGE (INITIAL 5M NEXT 5M PCTINCREASE 0);                                                                                                         
           >>>> SORT_AREA_RETAINED_SIZE 는 SORT_AREA_SIZE 의 반으로 하는것이 추천 사항이다.                                                                                                
                                                                                                           
        >>> 내부적인 래취의 경합 감소                                                                                                    
           사용자 프로세스가 SGA의 정보를 접근하려면 일종의 LOCK 과 유사한 내부적인 LATCH 를 소유해야 한다. 래취가 부족해서 경합이 일어나면                                                                                                
           수행속도가 느려지고 CPU 가 더 많이 필요하게 된다.                                                                                                
  %   SELCT NAME LATCH_NAME , GETS, MISSES, ROUND(DECODE(GET-MISSES,0,1,GET-MISSES) / DECODE(GETS,0,1,GETS),3),HITS_RATIO,SLEEPS                                                                                                         
           , ROUND(SLEEPS/DECODE(MISSES,0,1,MISSES),3) "SLEEPS/MISS"                                                                                                 
                 FROM STATS$LATCHES                                                                                           
                 WHERE GETS != 0                                                                                          
                 ORDER BY NAME;                                                                                          
           >>>> 위의 SQL 문의 결과중에서 HIT_RATIO 에 있는 래취 적중율이 0.97 이하가 되면 래취에 대한 경합이 발생하고 있다는것이다.                                                                                                
                                                                                                           
  래취에 대해서 나중에 정리하자.                                                                                                         
        >>> ROLLBACK 에 관련된 처리의 감소                                                                                                    
           일관성을 가지도록 갱신을 하기 위해서는 서열을 부여해야 하므로 메모리를 래취하는것이 반드시 필요하다,                                                                                                
           >>>> 큰롤백 세그먼트는 몇 개만 만들고 데이터 베이스가 가지고있는 가장 큰 테이블이 충분히 들어갈수있는 크기로 한다,                                                                                                
           >>>> 따로 사용할 롤백 세그먼트를 지정할수있다.                                                                                                
  %     SET TRANSACTION USE ROLLBACK SEGMENT rollback_segment_name                                                                                                         
                                                                                                           
  %    SELECT * FROM stats$roll;                                                                                                          
           >>>> 위의 SQL 의 실행결과에서  TRANSACTION table wait ratio = TRANS_TBLWAITS / TRANS_TBL_GETS 의 비율이 0.5%보다 크면 롤백                                                                                                
              세그먼트를 추가 시켜야 한다.                                                                                             
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
                                                                                                           
     <Oracle Hint>                                                                                                      
           // 힌트를 사용한 오더바이 부분범위처리로의 유도.                                                                                                
           select   /*+ INDEX_DESC(TABLE_NAME INDEX_NAME) */ DEPT,ENAME                                                                                                
                FROM EMP                                                                                             
                 WHERE DEPT = "SALES"                                                                                          
                                                                                                           
           select   /*+ INDEX(TABLE_NAME INDEX_NAME) */ DEPT,ENAME                                                                                                
                FROM EMP                                                                                             
                 WHERE DEPT = "SALES"                                                                                          
                                                                                                           
           // 클러스터의 강제 이용                                                                                                
           select /*+CLUSTER(A) */ SUM(count(*) FROM A                                                                                                 
              WHERE B between '1' and '10'                                                                                             
                    and RTRIM(결합인덱스컬럼 이름) = 'ㅁㄴ'