출처 : http://blog.naver.com/thtlsgkrtod?Redirect=Log&logNo=40042013285

public class Reply_DoWriteCommand implements CommandProcessor {
 
 public String exeucte(HttpServletRequest request, HttpServletResponse response) {

  ReplyRepository replyRe = new ReplyRepository();
  System.out.println("위치 :  Reply_DoWriteCommand 입니다 " );
 
  /*
   *  웹 어플리케이션 주소를 리턴 하는 메서드 설명
   */
 
  System.out.println( request.getContextPath() ); // 출력문 '/MvcLogic' 나의 웹어플리케이션 프로젝트 명
  System.out.println( request.getServletPath()); // 출력문 '/Servlet/Controller' 앞에 웹플리케이션을 제외한 한 경로
   
  /*
   * 절대 경로를 구하는 메서드를 이용해서 request.getRealPath( "스트링" ); 메서드를 사용 했다
   * 나의 생각은 "스트링"이 파일명과 일치 해서 해당 파일이 있는 절대 경로를 뽑아 내는 줄로 잘못 알고있었다..
   * 하지만 실제로는 현제 웹어플리케이션 절대 경로 + 스트링 문자열 이다 !
   * 현재 나의  웹어플리케이션의 절대 경로를 알고 싶을 경우   request.getRealPath( "" )  빈값을 주면 된다.
   */
 
  System.out.println( request.getRealPath( request.getContextPath() ) );
  // 출력문

'C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\MvcLogic' +   request.getContextPath()
    //   즉   'C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\MvcLogic\

  System.out.println( request.getRealPath( request.getServletPath() ) );
  // 출력문

'C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\MvcLogic' +  request.getServletPath()
  //  즉   'C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\MvcLogic\ServletController'

  System.out.println( request.getRealPath( "" ) );
  // 출력문 'C:\Program Files\Apache Software Foundation\Tomcat 6.0\webapps\MvcLogic'

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

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

즉 결론은

 request.getRealPath("")  --> 현 웹 에플리케이션 절대 경로를 리턴한다

이런 메일 올때마다 자칭 할일 많다고 생각하는 나는 짜증부터 밀려온다.

그냥 대충 쓰면되지 그걸 왜 따지냐고~~~ 라고 맘속으로 몇번이고 중얼중얼 거렸지만

나도 이 둘의 차이가 뭔지 모르는걸.. 대충 썼다는 뜻이지.

그래서 할수없이 네박사님에게 물어봐서 확실하게 개념 을 정립하게 되었다.

먼저 이 타입들 각 문자열이 뜻하는 의미를 알아보자.

L : Long
P : Pointer
C : Constant
T : TCHAR
STR : String

L : Long 은 Pointer 의 범위를 결정한다. 16비트 운영체제에서 명시적으로 지정해주고자 Long(4바이트) 형 포인터라고 지정하는 범위 결정자 이다. short 형 포인트도 물론 있다. 한마디로 32비트 포인트로 동작하라~! 란 뜻이다.

P : 말 그대로 포인터다. 문자열을 전달인자로 넘길때는 당연히 포인터를 써야지 모든 데이터를 넘길수있으므로...

T : 오늘 이넘  때문에 뚜껑열렸던 놈이다. M$ 에서만 그런건지 모든 C++ 에서 그런건지는 모르겠지만 아마도 M$ 에서만 그런것 같다. 표준 API 에서는 명시적으로 char 형과 wchar 형을 나눠놓았는데 M$ 에서는 이것을 통틀어서 TCHAR 으로 정의해놓았다.
그리고 만일 프로젝트가 UNICODE 이면 자동으로 wchar 으로 바뀌고 그렇지 않다면 char 을 쓴다는 뜻이다.

STR : 생략

그럼 LPCSTR 과 LPCTSTR 의 차이를 살펴보자.

1. Multibyte 문자열로 프로젝트를 만든 경우 위 두 타입은 동일하다. 왜냐하면
LPCSTR  : [long pointer] const char*   <== 이런 타입도 있나몰라. ㅡㅡ;
LPCTSTR : [long pointer] const char*

2. UNICODE 문자열로 프로젝트를 만든 경우는 이 두가지 타입이 다르다.
LPCSTR  : [long pointer] const char*  
LPCTSTR : [long pointer] const wchar*

그러니 잘 알고 사용하자~! 나처럼 욕먹지말고.

OpenProcess

VirtualAlloc
VirtualAllocEx

VirtualProtect
VirtaulProtectEx

VirtualQuery
VirtualQueryEx

ReadMemoryProcess
WriteMemoryProcess

GetKeyState
GetAsyncKeyState

keybd_event
mouse_event

SetWindowsHookExA
SetWindowsHookExW

SetCursorPos

SendMessageA
SendMessageW

PostMessageA
PostMessageW

SuspendThread

GetPixel

GetDC
GetDCEx

GetWindowDC

CreateDC

BeginPaint

BitBlt
StretchBlt

DeviceIoControl

GetWindowThreadProcessId

WaitForDebugEvent
- 디버그 중인 프로세스에서 발생하는 디버깅 이벤트를 기다림

DebugActiveProcess

DebugActiveProcessStop
- 지정된 프로세스를 디버깅하는 것을 멈춤

예의상 참고링크 : http://www.fkn0wned.com/forum/index.php?showtopic=4055

BASIC wall Hack

1)first u need to download a compliler
removed

2) Download the newest directx sdk from microsoft
3)setup your compiler link all the apropriate stuff
4)Dl AZorbix's d3d starter kit
http://files.filefront.com//;7469039;;/  <== 귀찮아서 올림

invalid-file

1. 인덱스 걸기
ALTER TABLE test ADD INDEX index_id (id)


2. 인덱스 다시 정렬하기
데이터가 많이 쌓이면 인덱스가 항상 최상의 상태로 정렬되어있지 않다. 그땐 아래 명령어를 통해서 다시 정렬을 해준다면 체감상(?) 성능이 샹항됨을 느낄수 있다고 한다. (내말이 아님)
mysql/var/디비명 에 들어가서
myisamchk -R1 *

3. 깨진 인덱스 복구하기

INDEX 사용하기

by kkaok
2003-06-24

인덱스의 활용

만약 우리가 집을 짓는데 제일 먼저 해야 할 일이 뭘까? 그것은 아마도 설계일 것이다. 기초가 되는 기본 설계를 잘 해야만이 그 후 작업이 원활하고 최적화가 되는 것이다.
프로그래머는 java, servlet, jsp뿐 아니라 최소한의 데이터베이스에 대해서도 알아야 한다. 게시판, 카운터, 일정관리 등을 만드는데 DB 설계를 다른 사람이 해줄 수도 있겠지만 대부분이 개발자가 설계하고 만들기 때문이다. 여기서는 DB에 대해 심도 깊은 공부를 할 수는 없지만 최소한의 지식에 대해 배우기로 한다.

인덱스란 무엇인가?

SQL서버에서 테이블을 만들고 데이터를 추가, 수정, 삭제 할 때 데이터의 레코드는 내부적으로 아무런 순서 없이 저장된다. 이때 데이터 저장영역을 Heap이라고 한다. Heap에서는 인덱스가 없는 테이블의 데이터를 찾을 때 무조건 전체 데이터 페이지의 처음 레코드부터 끝 페이지의 마지막 레코드까지 다 읽어서 검색조건과 비교하게 된다. 이런 식의 데이터 검색방법을 테이블 스캔(table scan) 또는 풀 스캔(full scan)이라고 한다. 이럴 경우 양이 많은 테이블에서 일부분의 데이터만 불러 올 때 풀 스캔을 하면 처리 성능이 떨어진다. 즉 인덱스는 데이터를 select 할 때 빨리 찾기 위해 사용된다.

인덱스 생성 시 고려할 점

인덱스를 생성 시에는 where 절과 join, order by 등과 관련된 칼럼중 사용 빈도가 높고 키 값의 선별도가 좋은 칼럼에 사용해야 한다. 반대로 사용 빈도가 낮고 칼럼의 선별도가 나쁜, 예를 들어 한 칼럼의 값이 true/false, 성별(M/F) 등에는 인덱스를 사용하지 않는 것이 좋다 또 테이블이 작거나 자주 갱신 될 때도 사용하지 않는 것이 좋다.

인덱스의 생성

인덱스에는 크게 clustered와 nonclustered 인덱스로 나눌 수 있다. clustered 인덱스는 물리적 정렬로 DB에 데이터를 입력 시 이것을 기준으로 입력이 된다. 따라서 한 테이블에 오직 하나만 존재 할 수 있으며 table을 열었을 때 order by를 사용하지 않아도 데이터가 clustered 인덱스에 따라 정렬이 되어 있는 것을 확인 할 수 있다. 물리적으로 정렬이 되어 있는 만큼 가장 빠른 처리를 한다. nonclustered 인덱스는 clustered 인덱스와는 달리 중복된 값을 가지면 한 테이블에 여러 개를 생성 할 수 있다. 이 외에 unique에 대해 알아보겠다. unique는 말 그대로 중복을 허용하지 않는 값을 보호 할 때 사용한다. 예를 들어 회원 관리 프로그램에서 아이디가 중복되는 것을 막고자 한다면 이 옵션을 사용하면 된다. 우리가 자주 사용하는 primary key의 경우에는 clustered와 unique 특성을 갖게 하는 제약키이다.

① mssql

인덱스생성 문법

CREATE [UNIQUE] [CLUSTERED | NONCLUSTERED] 
INDEX index_name ON table (column [,...n]) 
[WITH 
[PAD_INDEX] 
[[,] FILLFACTOR = fillfactor] 
[[,] IGNORE_DUP_KEY] 
[[,] DROP_EXISTING]
[[,] STATISTICS_NORECOMPUTE] 
] 
[ON filegroup]

인덱스의 생성 예제

create clustered index ix_kkaok on kkaok(seq) 
width DROP_EXISTING, FILLFACTOR = 80

kkaok 테이블에서 seq 칼럼에 대해 ix_kkaok라는 클러스터드 인덱스를 생성하라는 명령문이다.

DROP_EXISTING 옵션은 기존에 같은 이름의 인덱스가 존재한다면 삭제하고 생성하라는 의미이며 Fillfactor 값은 명시하지 않으면 기본적으로 100% 페이지에 채워 넣으라는 뜻이다. 지금은 80% 채워 넣고 20% 여유공간을 가지라는 의미이다.

결합 인덱스의 생성 예제

create index ix_kkaok2 on kkaok(seq,re_step)

seq와 re_step 두 개의 칼럼에 인덱스를 생성하였다. 각각의 칼럼에 대해 내림차순 정렬과 오름차순 정렬 옵션을 줄 수 있지만 mssql 7.0에서는 내림차순 정렬을 지원하지 않는다.

인덱스 보기

exec sp_helpindex '테이블이름'

인덱스 제거

drop index 'table.index'[,...n]

인덱스의 삭제 예제

drop index kkaok.ix_kkaok

제약키의 변경

primary key는 인덱스가 아니고 제약키이다. 따라서 인덱스를 삭제하는 방법으로 삭제 할 수는 없다. 제약키는 다음의 방법으로 삭제 또는 변경 할 수 있다.

제약키의 삭제
alter table kkaok drop constraint PK_kkaok

제약키의 추가변경
alter table kkaok add constraint PK_kkaok primary key(seq)

② oracle

인덱스생성 문법

CREATE [BITMAP | UNIQUE] 
INDEX index_name ON table (column[, column]...) ;

인덱스의 생성 예제

create unique index ix_kkaok_indx on kkaok(seq);

kkaok 테이블에서 unique 한 값으로 seq 칼럼에 대해 ix_kkaok_indx라는 인덱스를 생성하라는 명령문이다.

결합 인덱스의 생성 예제

create index ix_kkaok_indx2 on kkaok(seq,re_step);

seq 와 re_step 두 개의 칼럼에 인덱스를 생성한다. 각각의 칼럼에 대해 내림차순과 오름차순 정렬 옵션을 줄 수 있으나 hint를 사용시 정렬이 안되는 경우가 있어서 정렬과 관련된 것은 hint에서 처리를 하면 된다.

인덱스 보기

select index_name, index_type from user_indexes;

인덱스 제거

drop index 인덱명

인덱스의 삭제 예제

drop index ix_kkaok_indx;

제약키의 삭제 예제

alter table kkaok drop constraint kkaok_pk_re_step;

제약키의 추가 예제

alter table kkaok add constraint kkaok_pk_indx2 unique(seq);

③ mysql

인덱스생성 문법

BLOB과 TEXT 타입을 제외한 모든 mysql의 칼럼 타입은 인덱스로 사용될 수 있다. 한 테이블에는 16개의 인덱스를 생성할 수 있으며 최대 인덱스의 길이는 256바이트이다. 또한 인덱스에 사용되는 칼럼은 NOT NULL이어야 한다. 인덱스의 생성은 테이블을 생성할 때 다음처럼 생성하면 된다.

KEY [인덱스명] (col1(length),col2(length),...)

인덱스의 생성 예제

CREATE TABLE test (
    id CHAR(20) NOT NULL,
    name CHAR(200) NOT NULL,
    PRIMARY KEY (id),
    KEY index_name (name(200)));

인덱스의 추가 예제

ALTER TABLE test ADD INDEX index_id (id)

인덱스 제거

ALTER TABLE [테이블명] DROP INDEX [삭제할 인덱스명]

인덱스의 삭제 예제

ALTER TABLE test DROP INDEX index_name

PRIMARY KEY의 삭제

ALTER TABLE test DROP PRIMARY KEY

PRIMARY KEY의 추가

ALTER TABLE test ADD PRIMARY KEY (id)

http://www.kkaok.pe.kr

* 작업그룹 알아내기
작업그룹(workgroup) 은 netbios 에서 특정 피시를 그룹핑을 할때 사용하는 이름을 뜻한다.

자세한것은 다음 링크 참조.

http://kin.naver.com/open100/db_detail.php?d1id=1&dir_id=103&eid=kUCQ685h/QrAyvd7c/AY3lJl+CzPzJT0&qb=bmV0YmlvcyDA2773sde37A==

다음은 작업그룹의 이름을 알아내는 코드이다.

#include <lm.h>
#pragma comment (lib,"netapi32.lib")
LPSTR GetWorkGroupName(void)
{
    static CHAR sGroup[256];   
    memset(sGroup, 0x00, 256);   
    if ( GetVersion() < 0x80000000)              
    {    // WinNT series
        const    DWORD    dwLevel = 102;
        LPSTR    pszServerName = NULL;
        BOOL    fIsDLLLoaded = FALSE;
        {
            WKSTA_INFO_102    *pBuf = NULL;
            NET_API_STATUS        nStatus;

            nStatus = NetWkstaGetInfo( pszServerName, dwLevel, (LPBYTE*)&pBuf );

            if (nStatus == NERR_Success)
            {
                //유니코드를 스트링으로 변환
                WideCharToMultiByte(CP_ACP, 0, (const unsigned short *)pBuf->wki102_langroup,
                            -1, (char *)sGroup, sizeof(sGroup), 0, 0);
            }

            if (pBuf != NULL) NetApiBufferFree(pBuf);
        }
    }
    else
    {
        // 9X에서는 레지스트리에서 검색을 해야함..
        LONG result;
        HKEY hKey;     
        DWORD dwType = REG_SZ; 
        DWORD dwSize = 128;

        result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\VxD\\VNETSUP",
                            0, KEY_READ, &hKey);
        if (result == ERROR_SUCCESS)
        {
            result = RegQueryValueEx(hKey, "Workgroup", 0, &dwType, (LPBYTE)sGroup, &dwSize);
        }

        hKey = NULL;
        RegCloseKey(hKey);

 //       int nLen = min(*pdwSize,_tcslen(szTempGroupName));
   //     _tcsncpy( szGroupName, szTempGroupName, nLen  );
     //   szGroupName[nLen] = 0;
       // *pdwSize = nLen;
    }
    return sGroup;
}

일반적으로 swap 함수를 구현하는 방법은 다음과 간다.

void swap(int& a, int& b)
{
     int c = a;
     a = b;
     b = a;
}

하지만 c 라는 내부 변수를 사용하지 않고 간단하게 하는 방법은 없을까?

다음은 그 두가지 방법을 설명해준다.

void swap(int& a, int& b)
{
     a = a+b;
     b = a-b;
     a = a-b;
}

void swap(int& a, int& b)
{
     a = a^b;
     b = a^b;
     a = a^b;
}

그런데 과연 이렇게 해서 변수 2 혹은 4바이트를 아껴가면서 구현할 필요가 있을까?

뭐..

BOOL CUtil::getOsVersion(CString &osVersion)
{
 BOOL rtnV = TRUE;
 int resultValue = 0;
OSVERSIONINFOEX osvi;
 BOOL bOsVersionInfoEx;
 char tBuf[128];
 ZeroMemory(tBuf, 128);
 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if(!(bOsVersionInfoEx = GetVersionEx((OSVERSIONINFO *) &osvi))) {
  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 if(!GetVersionEx((OSVERSIONINFO *) &osvi)){}
   //return -1;
  return 0;
 }

switch(osvi.dwPlatformId) {
 case VER_PLATFORM_WIN32_NT:
  if(osvi.dwMajorVersion >= 5) {
   switch(osvi.dwMinorVersion) {
   case 0: //2000
    resultValue = 2000;
    //dest->Format("2000");
    break;
   case 1: //xp
    resultValue = 2001;
    //dest->Format("XP");
    break;
   case 2: //2003
    resultValue = 2003;
    //dest->Format("2003");
    break;
   default:
    //dest->Format("그냥 2000 이상");
    resultValue = 2000;
    break;
   }
  }else{
   //dest->Format("NT 4.0 이하");
   //NT 4.0 이하
   resultValue = 40;
  }
  break;
 case VER_PLATFORM_WIN32_WINDOWS:
  if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0) {
   resultValue = 95;
   //dest->Format("95");
   //윈도 95
  }
  if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10){
   resultValue = 98;
   //dest->Format("98");
   //윈도 98
  }
  if(osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90){
   resultValue = 99;
   //dest->Format("ME");
   //윈도 ME
  }
  //Win32
  //dest->Format("확인되지 않은 윈32 운영체제");
  break;
 case VER_PLATFORM_WIN32s:
  //dest->Format("Win32s");
  //윈도우 32s
  resultValue = 90;
  break;
 default:
  //dest->Format("측정 불가");
  //OS 측정 불가
  resultValue = 0;
  break;
 }
 
 switch(resultValue){
 case 95:
 case 98:
 case 2000:
 case 2003:
  osVersion.Format("%d", resultValue);
  break;
 case 99:
  osVersion.Format("ME");
  break;
 case 2001:
  osVersion.Format("XP");
  break;
 case 45:
  osVersion.Format("NT");
  break;
 default:
  rtnV = FALSE;
  break;
 }
 
 return rtnV;
}

MySQL Database의 경우 Oracle 이나 MS SQL Server에 비해서 대용량의 자료를 처리하는 경우가 적기에 튜닝에 필요성이 적은 것 같습니다. 그러나 웹이라는 환경은 많은 사용자가 동시에 접속을 할 수 있기에 항상 모니터링과 최적화는 기본이라고 생각합니다.

본 강좌에서는 기본적인 모니터링 방법과 Connection과 Memory 부분에 대한 튜닝 방법을 소개하도록 하겠습니다.

가. 모니터링 및 초기화 명령어

• show status - MySQL 데이타베이스의 현재 상황
• show Processlist - MySQL 프로세스 목록
• show variables - 설정 가능한 모든 변수 목록
• flush logs - MySQL의 로그파일 초기화
• flush status - MySQL 상태정보 초기화
• flush thread - 쓰레드 캐시에 저장된 쓰레드 초기화
• flush tables - MySQL에 캐싱된 테이블 초기화
• flush privileges - 권한정보 재 설정

나. Connection 튜닝

1. status

• Aborted_clients - 클라이언트 프로그램이 비 정상적으로 종료된 수
• Aborted_connects - MySQL 서버에 접속이 실패된 수
• Max_used_connections - 최대로 동시에 접속한 수
• Threads_cached - Thread Cache의 Thread 수
• Threads_connected - 현재 연결된 Thread 수
• Threads_created - 접속을 위해 생성된 Thread 수
• Threads_running - Sleeping 되어 있지 않은 Thread 수

2. system variables

• wait_timeout - 종료전까지 요청이 없이 기다리는 시간 ( TCP/IP 연결, Shell 상의 접속이 아닌 경우 )
• thread_cache_size - thread 재 사용을 위한 Thread Cache 수로써, Cache 에 있는 Thread 수보다 접속이 많으면 새롭게 Thread를 생성한다.
• max_connections - 최대 동시 접속 가능 수

그외에 status 또는 system variables 값은 참고의 Mysql 메뉴얼을 참조해 주십시요.

mysql> show variables like '%max_connection%';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| max_connections | 100   |
+-----------------+-------+
1 row in set (0.00 sec)
mysql> show status like '%connect%';
+----------------------+---------+
| Variable_name        | Value   |
+----------------------+---------+
| Aborted_connects     | 3782    |
| Connections          | 2961108 |
| Max_used_connections | 90      |
| Threads_connected    | 1       |
+----------------------+---------+
4 rows in set (0.01 sec)
mysql> show status like '%clients%';
+-----------------+-------+
| Variable_name   | Value |
+-----------------+-------+
| Aborted_clients | 2160  |
+-----------------+-------+
1 row in set (0.00 sec)
mysql> show status like '%thread%';
+------------------------+-------+
| Variable_name          | Value |
+------------------------+-------+
| Delayed_insert_threads | 0     |
| Slow_launch_threads    | 0     |
| Threads_cached         | 7     |
| Threads_connected      | 1     |
| Threads_created        | 1364  |
| Threads_running        | 1     |
+------------------------+-------+
6 rows in set (0.00 sec)

Cache Miss Rate(%) =  Threads_created / Connections * 100
Connection Miss Rate(%) = Aborted_connects / Connections * 100
Connection Usage(%) = Threads_connected / max_connections * 100

위의 경우는 Cache Miss Rate(%) = 0.05%, Connection Miss Rate(%) = 0.12%, Connection Usage(%) = 1%

3. 튜닝

• Connection Usage(%)가 100% 라면 max_connections 수를 증가시켜 주십시요. Connection 수가 부족할 경우 Too Many Connection Error 가 발생합니다.
• DB 서버의 접속이 많은 경우는 wait_timeout 을 최대한 적게 (10~20 정도를 추천) 설정하여 불필요한 연결을 빨리 정리하는 것이 좋습니다. 그러나 Connection Miss Rate(%) 가 1% 이상이 된다면 wait_timeout 을 좀 더 길게 잡는 것이 좋습니다.
• Cache Miss Rate(%) 가 높다면 thread_cache_size를 기본값인 8 보다 높게 설정하는 것이 좋습니다. 일반적으로 threads_connected 가 Peak-time 시 보다 약간 낮은 수치로 설정하는 것이 좋습니다.
• MySQL 서버는 외부로 부터 접속 요청을 받을 경우 인증을 위해 IP 주소를 호스트네임으로 바꾸는 과정을 수행하여 접속시에 불필요한 부하가 발생하게 됩니다. skip-name-resolve를 설정하시고 접속시에 IP 기반으로 접속을 하게 되면 hostname lookup 과정을 생략하게 되어 좀 더 빠르게 접속을 하실 수 있습니다.

다. Memory 튜닝

1. status

• key_block_unused - Key Cache에서 사용되고 있지 않은 Block 수
• key_reads - Key Block 읽기 요청시 Disk을 읽은 수
• key_read_requests - Key Block 읽기 요청수

2. system variables

• key_buffer_size - 인덱스를 메모리에 저장하는 버퍼의 크기
• table_cache - 전체 쓰레드가 사용할 오픈 가능한 테이블 수
• myisam_sort_buffer_size - 테이블 repair,Alter table,load data에 사용되는 버퍼 메모리 크기
• join_buffer_size - 조인을 위한 메모리 버퍼 크기
• record_buffer - 순차적인 검색을 위해 사용되는 메모리 버퍼 크기
• record_rnd_buffer - order by 절을 사용할 경우 디스크 사용을 피하기 위하여 사용하는 메모리 버퍼 크기
• sort_buffer - order by 와 group by에 사용되는 메모리 버퍼 크기
• tmp_table_size - group by 시 디스크를 사용하지 않고 임시 테이블을 만들기 위해 사용되는 메모리 크기
• key_cache_block_size - block 의 크기(bytes, 기본값 1024)

mysql> show status like '%key%';
+------------------------+-----------+
| Variable_name          | Value     |
+------------------------+-----------+
| Com_preload_keys       | 0         |
| Com_show_keys          | 2945      |
| Handler_read_key       | 365020739 |
| Key_blocks_not_flushed | 0         |
| Key_blocks_unused      | 222601    |
| Key_blocks_used        | 231960    |
| Key_read_requests      | 847204435 |
| Key_reads              | 4195954   |
| Key_write_requests     | 25034738  |
| Key_writes             | 16452136  |
+------------------------+-----------+
10 rows in set (0.00 sec)

Key Buffer Usage = 1 - ((Key_blocks_unused × key_cache_block_size) / key_buffer_size)
Key_reads/Key_read_requests Rate(%) =  Key_reads/Key_read_requests * 100
Key_reads/Key_read_requests Relative Rate(%) = (1- ^Key_reads/^Key_read_requests) * 100

* ^Key_Reads = Current Key_Rreads - Previous Key_Reads

3. 튜닝

• key_buffer_size는 총 메모리 크기의 25% 정도의 크기로 설정하는 것이 좋습니다.
• Key_reads/Key_read_requests Rate(%)은 일반적으로 1%보다 적습니다. 1% 보다 높다면 Key Cache가 아닌 디스크를 읽은 경우가 많다고 판단할 수 있습니다. 또한 Key_reads/Key_reads_requests Relative Rate(%) 값이 지속적으로 90% 이상일 경우는 key_buffer_size가 효율적으로 설정되어 있다고 생각하시면 됩니다. 하지만 데이터베이스가 엄청나게 크거나 여러 데이터를 골고루 많이 읽는 데이터베이스라면 아무리 많은 양의 키 캐시를 설정해도 90% 이상의 적중률을 얻을 수는 없습니다.

라. 적용

system variables은 my.cnf 또는 my.ini 파일을 수정 후 MySQL Server 를 재시작 해 주십시요.

[www@smson www]$ vi /etc/my.cnf  
# The MySQL server
[mysqld]
port            = 3306
socket          = /tmp/mysql.sock
skip-locking
skip-name-resolve
key_buffer = 256M
max_allowed_packet = 1M
table_cache = 256
sort_buffer_size = 1M
read_buffer_size = 1M
read_rnd_buffer_size = 4M
myisam_sort_buffer_size = 64M
thread_cache = 8
query_cache_size= 16M
# Try number of CPU's*2 for thread_concurrency
thread_concurrency = 8
wait_timeout = 120
~~~
[root@smson mysql]# /usr/local/mysql/share/mysql/mysql.server restart

• http://dev.mysql.com/doc/refman/5.0/en/server-system-variables.html
• http://dev.mysql.com/doc/refman/5.0/en/server-status-variables.html
• http://jeremy.zawodny.com/blog/archives/000173.html
• http://www.dbguide.net/know/know101003.jsp?IDX=887&catenum=14
• High Performance MySQL
• http://dev.mysql.com/books/hpmysql-excerpts/ch06.html
• http://www.mysqlperformanceblog.com/mysql-performance-presentations/

출처 : http://blog.naver.com/reyus/60012240449

가비지 콜렉션
2004년 1월의 테크팁이었던 Monitoring Class Loading and Garbage Collection에서는 자바 커맨드 라인 툴 (자바 애플리케이션 런쳐)를 이용하여 커맨드 라인 옵션인 -verbose:gc에 대해서 알아보았다. 표준이 아니라는 이유로 -XX 옵션에 대해 신경 쓰지 않는다거나, 옵션의 균질성을 중요시한다거나, 또는 현재 사용하고 있는 옵션에 대해서 알고 싶다면 다음과 같이 -verbose:gc 를 입력해보자.

 -XX:+PrintGC -XX:+TraceClassUnloading
이것은 -verbose:gc 옵션이 어떻게 번역되는지를 보여준다.

이 옵션은 애플리케이션이 실행되는 동안 가비지 콜렉션 이벤트의 리포트를 요구한다. J2SE v1.4.2에서는 가비지 콜렉터를 컨트롤하는 다른 많은 커맨드 라인이 있다. 코드의 어느 라인도 변경하지 않고 애플리케이션의 성능을 최대한으로 활용하려면, 이 옵션들을 최소한 하나 이상 사용할 수가 있다. 이번 팁에서는 가비지 콜렉터를 컨트롤하는 부수적인 많은 자바 커맨드 라인을 다룰 것이지만, 가비지 콜렉션 튜닝 옵션의 전체를 말하지는 않는다.

자바 애플리케이션 런쳐는 표준 커맨드-라인 스위치와 비표준 커맨드-라인 스위치를 모두 동반한다. -verbose:gc 옵션에 관한 정보에 대해 알아보려면, 특정 플랫폼별로 다음 웹페이지를 참고하자.

Win32
Solaris
Linux

위의 참고 페이지에는 몇몇 비표준 옵션들에 대해서도 나와있다. 자바 커맨드 라인 툴에서 표준 옵션인 -X을 실행하면 사용자의 플랫폼을 위한 비표준 옵션을 보여준다.

솔라리스 플랫폼이라면, java -X 을 실행했을 경우 출력되는 내용은 다음과 같다.

 -Xmixed mixed mode execution (default) -Xint interpreted mode execution only -Xbootclasspath:<directories and zip/jar files separated by :> set search path for bootstrap classes and resources -Xbootclasspath/a:<directories and zip/jar files separated by :> append to end of bootstrap class path -Xbootclasspath/p:<directories and zip/jar files separated by :> prepend in front of bootstrap class path -Xnoclassgc disable class garbage collection -Xincgc enable incremental garbage collection -Xloggc:<file> log GC status to a file with time stamps -Xbatch disable background compilation -Xms<size> set initial Java heap size -Xmx<size> set maximum Java heap size -Xss<size> set java thread stack size -Xprof output cpu profiling data -Xrunhprof[:help]|[:<option>=<value>, ...] perform JVMPI heap, cpu, or monitor profiling -Xdebug enable remote debugging -Xfuture enable strictest checks, anticipating future default -Xrs reduce use of OS signals by Java/VM (see documentation) -Xcheck:jni perform additional checks for JNI functions The -X options are non-standard and subject to change without notice.
위의 출력값의 마지막 줄을 주목하자. 그러한 비표준 옵션들을 사용하는 것은 사용자의 책임 하에 있음을 분명히 나타내고 있다.

가비지 콜렉션을 위한 세 가지 특정한 비표준 옵션은 -Xnoclassgc, -Xincgc, 그리고 -Xloggc:<file>이다. -Xnoclassgc 옵션을 지정한다면, 콜렉션이 발생하지만 클래스들은 permanent generation으로부터 수집되지 않는다. 이는 콜렉션이 수거하는 메모리가 없음을 의미한다. 만약 클래스를 로딩하려고 할 때 이미 로딩된 클래스들을 위해 메모리를 써버렸다면 콜렉션은 문제를 해결하지 않을 것이다.

썬의 1.4.2 구현에서 -Xincgc은 -XX:+UseTrainGC 옵션과 동등한 값을 가진다. 즉, -Xincgc은 old generation을 위해서 디폴트 값에서 주어진 "serial" 콜렉터를 사용하기 보다는 "train"콜렉터를 사용한다. ("generations"의 개념은 이번 팁의 후반에서 다루게된다.) train 콜렉터는 약 10%의 퍼포먼스 부하를 발생시킨다. 또한 old generation 전체를 한 번에 수집할 수 없기 때문에 약간의 공간적인 부하(space overhead)도 발생한다. train 콜렉터는 점진적으로 작동하는 장점을 가지기 때문에 휴지 시간이 상당히 짧다. J2SE 1.5.0 베타 릴리즈에서는 -Xincgc 플래그는 train 콜렉터보다는 CMS(concurrent mark sweep) 콜렉터를 인보킹하게 된다. 그 이유는, CMS 콜렉터가 train 콜렉터보다 더 균일하기 때문이다.

-Xloggc 옵션을 지정해줌으로써 -verbose:gc 출력값의 등가를 파일로 출력할 수 있다. -verbose:gc 에 의한 출력값과 비교해 보면, -Xloggc 에 의한 출력값은 한 가지 추가적인 항목을 포함하는데, 그것은 애플리케이션에서의 첫 콜렉션이 일어난 시간에서부터 가비지 콜렉션이 발생한 시간에 대한 정보이다. 다음의 -Xloggc 샘플 출력값에서 살펴보자.

 0.000: [GC 512K->153K(1984K), 0.0198483 secs] 0.372: [GC 506K->281K(1984K), 0.0206428 secs] 0.393: [Full GC 281K->281K(1984K), 0.0888926 secs] 0.519: [GC 947K->941K(1984K), 0.0045715 secs] 0.524: [Full GC 941K->941K(1984K), 0.0797666 secs] 0.650: [GC 2107K->1597K(2808K), 0.0013546 secs] 0.838: [GC 2107K->1700K(2808K), 0.0116557 secs
파일에 재전송할 필요없이 -XX:+PrintGCTimeStamps 옵션을 지정해줌으로써 -Xloggc 출력값에 시간 소인을 나타낼 수 있다.

-Xnoclassgc, -Xincgc 과 -Xloggc:<file> 이외에도 가비지 콜렉터를 컨트롤하는 다른 옵션들이 존재한다. 예를 들자면, 콜렉터가 실행할 때 간접적으로 영향을 끼치도록 -Xms와 -Xmx 옵션을 사용하여 메모리 할당의 풀 사이즈를 변경할 수 있다. -Xms의 값을 크게 지정해주면, 그만큼 큰 자바 객체 힙으로 작업하게 된다. 이것은 힙을 채우는 데에 더 많은 시간이 걸린다는 것을 의미하고 결과적으로 콜렉션을 피하지는 않지만 미루게 된다는 것이다. 큰 -Xms 값은 또한 더 많은 시스템 리소스를 소모하게 된다. 반면 -Xmx의 값을 크게 지정하면, 자바 객체 힙의 사이즈가 필요 시에 커질 수 있게 된다. 이렇게 값이 큰 객체 힙은 조금 덜 빈번하게 가비지 콜렉트된다는 점 외에는 모든 점이 동일하다. 따라서 이 옵션을 통해 가비지 콜렉션이 빈번하지만 짧은 시간동안 일어나는 것과, 횟수는 적지만 오랜 시간동안 가비지 콜렉션이 일어나는 것 중 하나를 선택할 수 있다. 하지만 각각의 콜렉션이 부하를 발생하기 때문에, 사용자가 정의하는 요구조건에 따라 더 나은 접근법은 달라지게 되어있다.

-Xms 와 -Xmx 외에도 가비지 콜렉션에 영향을 주는 비표준 옵션들이 존재한다. 그 옵션들은 java -X 도움말에서 볼 수 없는데, 그 이유는 이 옵션들은 비표준 옵션이기 때문에 두개의 X를 사용해야하기 때문이다.

만약 힙의 최소값과 최대값을 지정해주고자 한다면 (이 때, 디폴트 값의 범위는 40%~70%), -XX:MinHeapFreeRatio=<Minimum> 옵션과 -XX:MaxHeapFreeRatio=<Maximum> 옵션을 사용하면 된다. 그러나 최소값을 너무 작게 설정해놓으면, 힙은 콜렉션 후에 충분한 여유공간을 확보하지 못하게 되므로, 단기간 내에 또다시 콜렉팅을 해야할 수도 있다. 반면, 최소값을 크게 설정하면, 더 많은 "head room"이 생기므로 다음 콜렉션 때까지 시간을 지연시킬 수 있을 것이다. -XX:MinHeapFreeRatio 의 값을 크게 했을 때의 단점은 시스템 메모리가 이 가상 장치에 고정되기 때문에 사용자의 또 다른 애플리케이션에 사용될 수 없다는 점이다.

-XX 세트내의 다른 비표준 옵션들은 가비지 콜렉터의 작동 방법에 영향을 끼친다. -XX:+UseConcMarkSweepGC 커맨드 라인 플래그("concurrent mark sweep garbage collection"의 줄임말)는 병행(concurrent) 가비지 콜렉터를 실행시킨다. -XX:+UseConcMarkSweepGC 콜렉터는 old generation을 동시에 콜렉팅한다. 그 이유는 전반적인 콜렉션 같은 old generation 들은 콜랙팅할 때 대체적으로 시간이 오래 걸려서 병행 가비지 콜렉터를 실행시키는 것이 더 효과적이기 때문이다. 이는 애플리케이션에서 가비지 콜렉션 휴지 시간을 짧게 할 수 있도록 프로세싱 파워를 활용한다는 것을 말한다. -XX:+UseParallelGC 커맨드 라인 플래그는 병렬 가비지 콜렉팅을 가능하게 한다. -XX:+UseParallelGC 콜렉터는 오직 다중 프로세서를 이용한 young generation만을 콜렉팅한다. 이 접근법은 처리율은 높이지만, 전반적인 콜렉션의 휴지 시간을 줄이지는 못한다.

또 하나의 흥미로운 옵션인 -XX:+PrintGCDetails 는 각각의 콜렉션에서 각 generation에 어떤 일이 발생했는지를 보여준다. (단, permanent generation 에 대한 자세한 사항들은 보여주지 않는다. 이 점은 JDK 1.5.0.에서 수정되었다.)

SwingSet2의 데모에 사용된 -XX:+PrintGCDetails의 예제를 살펴보자. (출력값의 라인들은 테크팁 페이지의 경계선에 맞추기 위해 나누어주었다.)

 java -Xloggc:details.out -XX:+PrintGCDetails -jar /home/eo86671/j2sdk1.4.2/demo/jfc/SwingSet2/SwingSet2.jar 0.000: [GC 0.000: [DefNew: 511K->64K(576K), 0.0182344 secs] 511K->153K(1984K), 0.0185255 secs] 1.387: [GC 1.387: [DefNew: 417K->64K(576K), 0.0192086 secs] 1.407: [Tenured: 217K->281K(1408K), 0.0725645 secs] 506K->281K(1984K), 0.0923346 secs] 1.559: [GC 1.559: [DefNew: 10K->3K(576K), 0.0044098 secs] 1.564: [Tenured: 937K->941K(1408K), 0.0741569 secs] 948K->941K(1984K), 0.0790573 secs] 1.703: [GC 1.703: [DefNew: 510K->0K(576K), 0.0011627 secs] 2107K->1597K(2808K), 0.0013820 secs] 2.210: [GC 2.210: [DefNew: 509K->64K(576K), 0.0112637 secs] 2107K->1710K(2808K), 0.0115942 secs] 2.927: [GC 2.927: [DefNew: 575K->64K(576K), 0.0170128 secs] 2222K->1841K(2808K), 0.0173293 secs] 8.430: [GC 8.430: [DefNew: 576K->64K(576K), 0.0142839 secs] 2353K->2025K(2808K), 0.0156266 secs] 8.823: [GC 8.823: [DefNew: 494K->64K(576K), 0.0164915 secs] 2456K->2243K(2808K), 0.0166323 secs] 8.856: [GC 8.856: [DefNew: 569K->41K(576K), 0.0058505 secs] 8.862: [Tenured: 2341K->1656K(2360K), 0.1464764 secs] 2749K->1656K(2936K), 0.1526133 secs]
변경내용이 그 결과에 어떤 영향 (예를 들어서, 콜렉션간의 시간 연장이나 각각 특정 휴지 시간의 감소)을 주는지를 알아보기 위해 -Xms 옵션과 -Xmx 옵션을 조정해보자.

앞서 'generations'의 힙 공간에 대해 언급한 바 있다. 이 말이 무슨 의미인지 궁금하다면, 여기 짤막한 설명을 참조하자. JRE 1.4.2 에서 힙은 young, old, 그리고 permanet와 같이 세 개의 generation으로 구분된다. young generation은 객체가 생성된 장소이다. 이 generation의 사이즈는 -XX:NewSize 옵션과 -XX:MaxNewSize 옵션에 의해 컨트롤된다. 새로운 객체를 보유하게 되면, old generation으로 승격된다. old generation의 사이즈는 전체 힙 사이즈 (-Xms 과 -Xmx) 에서 young generation의 사이즈 (-XX:NewSize 과 -XX:MaxNewSize)를 감한 사이즈로 계산된다. young generation은 명시적 크기보다는 -XX:NewRatio=를 이용하여 더 잘 지정할 수 있는데, -XX:NewRatio= 옵션은 힙 설정의 전체 사이즈를 설정해주기 때문이다. 선택한 사이즈는 콜렉팅 되는 시간에 대해 콜렉션의 횟수를 결정하게 된다. 어떤 애플리케이션들은 짧은 휴지 시간을 요구하는 한편, 콜렉터의 효율성을 필요로 하는 애플리케이션들도 있다. (많은 애플리케이션에서 이 단계의 튜닝을 해줄 필요는 전혀 없다.)

마지막으로 언급할 GC옵션은 -XX:+DisableExplicitGC이다. System.gc()의 호출을 이용하여 가비지 콜렉터를 실행하라는 명령을 했을 때, 시스템이 이를 무시하기를 원한다면 이 옵션을 사용해보자. 가비지 콜렉터는 프로그래머가 명령했을 때가 아닌, 필요시에 계속해서 실행되고 있을 것이다. 하지만 프로그래머의 명령을 무시하는 것이 좋은 생각일까? 아마도 아닐 것이다. 왜냐하면, 프로그래머가 가비지 콜렉터를 실행하기 적당한 시점이라고 생각할 수 있기 때문이다. 물론, 만약 공유 라이브러리를 사용하고 있고, 실행 콘텍스트가 프로그래머의 원래의 계획과 다르다면, 이러한 새로운 상황에 유효하지 않을 수도 있다.

가비지 콜렉션에 관련된 옵션들에 대해 좀더 자세한 정보를 원한다면, Tuning Garbage Collection with the 1.4.2 Java Virtual Machine를 읽어보기 바란다. 튜닝을 할 때는 튜닝의 목적이 성능 향상인지, 짧은 휴지 시간인지 아니면 작은 범위의 ㄴ메모리 사용을 위한 것인지 그 목적을 확실히 해야 한다. JVM이 업데이트 되면서 선택할 수 있는 튜닝 옵션들도 다시 한번 살펴 보아야 한다. 이번 팁에서 다룬 옵션들의 대부분은 썬의 런타임 환경 1.4.2 릴리즈에 한정됨을 기억하자. 1.5.0 릴리즈는 고유의 컨트롤 셋과 디폴트 셋을 가진다.

if (navigator.appName == 'Netscape')
var language = navigator.language;
else
var language = navigator.browserLanguage;
/*-------------------------------------------------------------
Netscape instructions: 
In Netscape, find the language you want to redirect by going to
Edit Menu --> Preferences...
Then click the '+' box next to 'Navigator' and click 'Languages'
Click 'Add' then find the languages you want and add them below.
---------------------------------------------------------------
Microsoft Internet Explorer instructions: 
In MSIE, find the language you want to redirect by going to
Tools Menu --> Internet Options...
Then click the 'Languages' button near the bottom of the page.
Click 'Add' then find the languages you want and add them below.
-------------------------------------------------------------*/
if (language.indexOf('en') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('nl') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('fr') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('de') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('ja') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('it') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('pt') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('es') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('sv') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else if (language.indexOf('zh') > -1) document.location.href = 'http://www.kfiglobal.or.kr/eng/';
else
document.location.href = 'http://www.kfiglobal.or.kr/'; //기본적으로 한국어.

<<-------------------------------------------------------------------->>

// 이 소스는 BinGol님의 소스를 사용했으며 출처는 http://www.miniwini.com입니다.
// 언어 리스트
// 각 언어에 해당되는 페이지 파일은 ko.htm(한국)이며
// 파일의 확장자는 소스 아래에서 지정이 가능하다.
languagesq = new Object;
languagesq["un"] = "un"; //알려지지 않은 언어
languagesq["cn"] = "cn"; //중국어 (simp.)
languagesq["cs"] = "cs"; //체코슬로바키아어
languagesq["da"] = "da"; //덴마크어
languagesq["de"] = "de"; //독일어
languagesq["el"] = "el"; //그리스어
languagesq["en"] = "en"; //영어
languagesq["es"] = "es"; //스페인어
languagesq["fc"] = "fc"; //프랑스(캐나다)어
languagesq["fi"] = "fi"; //핀란드어
languagesq["fr"] = "fr"; //프랑스어
languagesq["hu"] = "hu"; //헝가리어
languagesq["it"] = "it"; //이탈리아어
languagesq["ja"] = "ja"; //일본어
languagesq["ko"] = "ko"; //한국어
languagesq["nl"] = "nl"; //네델란드어
languagesq["no"] = "no"; //노르웨이어
languagesq["pl"] = "pl"; //폴란드어
languagesq["pt"] = "pt"; //브라질어
languagesq["ru"] = "ru"; //러시아어
languagesq["sv"] = "sv"; //스웨덴어
languagesq["tr"] = "tr"; //터키어
languagesq["uk"] = "uk"; //영어 (UK)
languagesq["tw"] = "tw"; //중국어 (trad.)
languagesq["de-de"] = "de-de"; //독일어
languagesq["en-gb"] = "en-gb"; //영어 (UK)
languagesq["en-us"] = "en-us"; //영어 (US)
languagesq["es-es"] = "es-es"; //스페인어
languagesq["fr-fr"] = "fr-fr"; //프랑스어
languagesq["ja-jp"] = "ja-jp"; //일본어
lang = "un";
Component = "Unknown browser";
platform = "Unknown platform";
OS = "";
version = parseFloat(navigator.appVersion);
UA = navigator.userAgent;
ua = navigator.userAgent.toLowerCase();
if (((start = ua.indexOf("[")) > 0) && ((end = ua.indexOf("]")) == (ua.indexOf("[") + 3))) {
 language = ua.substring(start+1, end);
 } else if (navigator.language) {
  language = navigator.language.toLowerCase();
  } else if (navigator.userLanguage) {
   language = navigator.userLanguage.toLowerCase();
  }
  if (languagesq[language]) {
 lang = language;
}

물론 내용은 직접작성한것이 아니라 웹사이트를 긁어왔다.
출처 : http://myhome.hanafos.com/~kukdas/doc/c_lect/c_lect-8.html

(2) #line

- 사용법은 다음과 같다.

#line 라인번호 "파일명" 또는 #line 라인번호

#line 문은 기정의 매크로상수 __LINE__ 과 __FILE__ 을 각각 라인번호와 파일명으로 바꾼다. 파일명을 생략하면 __FILE__ 은 바뀌지 않는다.

#define MACRO
#ifdef MACRO
#line 0 "direct.c"  /* MACRO 가 정의되어 있을때만 컴파일됨 */
#endif
 
void main(void)
{
   printf("Line : %d, Filename : [%s]\n",__LINE__,__FILE__);
   #line 100 "main.c"
   printf("Line : %d, Filename : [%s]\n",__LINE__,__FILE__);
}
 
(예상 결과)
Line : 5, Filename : [DIRECT.C]
Line : 101, Filename : [MAIN.C]
 
(실제 결과)
Line : 8, Filename : [C-TEST4.C]
Line : 10, Filename : [C-TEST4.C]

(설명)

#line, __LINE__, __FILE__ 의 사용법을 보인 예이다.
이 파일의 이름은 C-TEST4.C 이다.
실제로 결과는 예상과 전혀 다르게 나왔다.
#line 지시자가 전혀 효과가 없는 것이다.
아마 Turbo-C 2.0의 버그인 듯하다.

GetSystemDefaultUILanguage  [인스톨된 언어값을 구할때]
GetSystemDefaultLCID  [시스템 locale 기본 언어값을 구할때]
GetSystemDefaultLangID  [시스템 기본 언어값을 구할때]
GetUserDefaultLangID  [유저 기본 언어값을 구할때]

이 함수들의 리턴값은 다음과 같습니다. (윈도 레지스터리에 등록되어 있는 값이기도 합니다. [예]한국: 1042 (0x412))

ps. 21514 값이 참 인상적입니다.

#include <windows.h>
#include <strsafe.h>

#define MAX_THREADS 3
#define BUF_SIZE 255

typedef struct _MyData {
    int val1;
    int val2;
} MYDATA, *PMYDATA;

DWORD WINAPI ThreadProc( LPVOID lpParam ) 
{ 
    HANDLE hStdout;
    PMYDATA pData;

    TCHAR msgBuf[BUF_SIZE];
    size_t cchStringSize;
    DWORD dwChars;

    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if( hStdout == INVALID_HANDLE_VALUE )
        return 1;

    // Cast the parameter to the correct data type.

    pData = (PMYDATA)lpParam;

    // Print the parameter values using thread-safe functions.

    StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
        pData->val1, pData->val2); 
    StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);
    WriteConsole(hStdout, msgBuf, cchStringSize, &dwChars, NULL);

    // Free the memory allocated by the caller for the thread 
    // data structure.

    HeapFree(GetProcessHeap(), 0, pData);

    return 0; 
} 
 
void main()
{
    PMYDATA pData;
    DWORD dwThreadId[MAX_THREADS];
    HANDLE hThread[MAX_THREADS]; 
    int i;

    // Create MAX_THREADS worker threads.

    for( i=0; i<MAX_THREADS; i++ )
    {
        // Allocate memory for thread data.

        pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                sizeof(MYDATA));

        if( pData == NULL )
            ExitProcess(2);

        // Generate unique data for each thread.

        pData->val1 = i;
        pData->val2 = i+100;

        hThread[i] = CreateThread( 
            NULL,              // default security attributes
            0,                 // use default stack size  
            ThreadProc,        // thread function 
            pData,             // argument to thread function 
            0,                 // use default creation flags 
            &dwThreadId[i]);   // returns the thread identifier 
 
        // Check the return value for success. 
 
        if (hThread[i] == NULL) 
        {
            ExitProcess(i);
        }
    }

    // Wait until all threads have terminated.

    WaitForMultipleObjects(MAX_THREADS, hThread, TRUE, INFINITE);

    // Close all thread handles upon completion.

    for(i=0; i<MAX_THREADS; i++)
    {
        CloseHandle(hThread[i]);
    }
}

TerminateProcess() 를 단순히 사용할 수 도 있지만 쫄다구프로세서들이 알아서 종료한다면 더 매끄럽지 않을까요?

어머니가 밖에서 노는 자식들에게 저녁먹이려고 억지로 끌고 집에 들어오는것 보다 애들이 어머니 부름에 알아서 집에 들어온다면 훨씬 더 화목합니다.

[방법]
* 관리자프로세서에서 이벤트를 생성합니다. 이때 이벤트는 수동리셋이벤트(Manual Reset Event)로 생성합니다.
* 관리자프로세서는 언제든 SetEvent() 로 이벤트를 셋 합니다.
* 쫄다구프로세서는 항상 이벤트가 세팅되었는지 검사를 합니다. 내부에서 따로 스레드를 생성시켜서 이벤트를 기다려도 되고 메인스레드에서 이벤트를 기다려도 됩니다.
* 관리자프로세서가 이벤트를 셋 하면 쫄다구프로세서는 이벤트를 받아서 종료루틴을 처리합니다.

관리작 프로세서가 이벤트를 셋 해놓고 핸들을 닫고 바로 종료 하더라도 쫄다구 프로세서는 이벤트를 받을 수 있습니다.

library 의 사용

int ysum(int a, int b); 
int ydiff(int a, int b);
			

#include "mysum.h"
int ysum(int a, int b)
{
    return a + b; 
}
int ydiff(int a, int b)
{
    return a - b;
}
			

[root@localhost test]# gcc -c mysum.c
[root@localhost test]# ar rc libmysum.a mysum.o
			

#include "mysum.h"
#include <stdio.h>
#include <string.h>

int main()
{
    char oper[5];
    char left[11];
    char right[11];
    int  result;

    memset(left, 0x00, 11);
    memset(right, 0x00, 11);

    // 표준입력(키보드)으로 부터  문자를 입력받는다.
    // 100+20, 100-20 과 같이 연산자와 피연산자 사이에 공백을 두지 않아야 한다.  
    fscanf(stdin, "%[0-9]%[^0-9]%[0-9]", left, oper, right);
    if (oper[0] == '-')
    {
        printf("%s %s %s = %d\n", left, oper, right, 
                        ydiff(atoi(left), atoi(right)));
    }
    if (oper[0] == '+')
    {
        printf("%s %s %s = %d\n", left, oper, right, 
                        ysum(atoi(left), atoi(right)));
    }
}
			

[root@localhost test]# gcc -o print_sum print_num.c -L./ -lmysum
			

# gcc -fPIC -c mysum.c
# gcc -shared -W1,-soname,libmysutff.so.1 -o libmysum.so.1.0.1 mysum.o
# cp libmysum.so.1.0.1 /usr/local/lib
# ln -s /usr/local/lib/libmysum.so.1.0.1 /usr/local/lib/libmysum.so			

[root@coco test]# gcc -o print_sum print_sum.c -L/usr/local/lib -lmysum
			

[root@coco library]# ./print_sum
./print_sum: error while loading shared libraries: libmysub.so: cannot open shared object file: No such file or directory
			

[root@localhost test]# export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/my/lib 
			

[root@localhost test]# cat /usr/my/lib >> /etc/ld.so.conf 
[root@localhost test]# ldconfig
			

#include <dlfcn.h>

void *dlopen (const char *filename, int flag);
const char *dlerror(void);
void *dlsym(void *handle, char *symbol);
int dlclose(void *handle); 
			

+,ysum,libmysum.so
-,ydiff,libmysum.so
				

#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <string.h>

struct input_data
{
    char    oper[2];
    char    func[10]; 
    char    lib[30];
};

int main(int argc, char **argv)
{
    char oper[2];
    char left[11];
    char right[11];
    char buf[50];
    char null[1];
    int data_num;

    struct input_data plug_num[10]; 

    void *handle;

    int (*result)(int, int);
    int i;
    char *error;

    FILE *fp;

    // 설정파일을 읽어들이고 
    // 내용을 구조체에 저장한다. 
    fp = fopen("plugin.cfg", "r");
    data_num = 0;
    while(fgets(buf, 50, fp) != NULL)
    {
        buf[strlen(buf) -1] = '\0';
        sscanf(buf, "%[^,]%[,]%[^,]%[,]%[^,]", plug_num[data_num].oper, 
                                               null,    
                                               plug_num[data_num].func, 
                                               null,
                                               plug_num[data_num].lib);
        data_num ++;
    }
    fclose(fp);

    printf("> ");
    memset(left, 0x00, 11);
    memset(right, 0x00, 11);
    fscanf(stdin, "%[0-9]%[^0-9]%[0-9]", left, oper, right);

    // 연산자를 비교해서 
    // 적당한 라이브러리를 불러온다. 
    for (i  = 0; i < data_num ; i++)
    {
        int state; 
        if ((state = strcmp(plug_num[i].oper, oper)) == 0) 
        {
            printf("my operator is      : %s\n", plug_num[i].oper);
            printf("my call function is : %s\n", plug_num[i].func);
            break;
        }
    }    

    if (i == data_num)
    {
        printf("--> unknown operator\n");
        exit(0);
    }

    handle = dlopen(plug_num[i].lib, RTLD_NOW);
    if (!handle)
    {
        printf("open error\n");
        fputs(dlerror(), stderr);
        exit(1);
    }

    // 연산자에 적당한 함수를 불러온다. 
    result = dlsym(handle, plug_num[i].func);
    if ((error = dlerror()) != NULL)
    {
        fputs(error, stderr);
        exit(1);
    }

    printf("%s %s %s = %d\n",left, oper, right, result(atoi(left), atoi(right)) ); 

    dlclose(handle);
}
				

[root@localhost test]# gcc -o print_sum_dl print_sum_dl.c -ldl 
				

  
[root@localhost test]# ./print_sum_dl
> 99+99
my operator is      : +
my call function is : ysum
99 + 99 = 198
[root@localhost test]#
				

int multi(int a, int b);
int div(int a, int b);
				

int multi(int a, int b)
{
    return a * b;
}

int div(int a, int b)
{
    return a / b;
}
				

[root@localhost test]# gcc -c -fPIC mymulti.c
[root@localhost test]# gcc -shared -W1,-soname,libmymulti.so.1 -o libmymulti.so.1.0.1 mymulti.o
				

 
+,ysum,libmystuff.so
-,ydiff,libmystuff.so
*,ymulti,libmymulti.so.1.0.1
/,ydiv,libmymulti.so.1.0.1
				

[root@localhost test]# ./print_sum_dl
> 10*10
my operator is      : *
my call function is : ymulti
10 * 10 = 100

[root@localhost test]# ./print_sum_dl
> 10/10
my operator is      : /
my call function is : ydiv
10 / 10 = 1
				

"Warning: mysql_query(): Unable to save result set in c:\apm_setup\htdocs\mac\list.htm on line 76
Incorrect key file for table: 'glog'. Try to repair it"

구체적으로 이런 로그를 볼 수 있다.

이것은 비정상적으로 시스템이 종료되거나 DB서버를 비정상적으로 종료했을 때 DB 테이블의 유효성이 깨져서 생기는 문제이다.

정확한 원인을 파악하기 위해서는 해당 DB에 접속해서 다음과 같은 쿼리를 던져 본다.

* Ctrl+F3 : 현재 커서가 있는 위치의 단어가 나오는 다음 위치를 찾아줍니다.
Ctrl+Shift+F3을 누르면 이전 걸 찾아주죠.

* Ctrl+H : replace입니다. 특히 일정부분안의 변수 이름을 변경하거나 할 때 범위를
선택한 다음에 Ctrl+H를 누르면 편하죠.

* Ctrl+], Ctrl+E : 괄호 짝을 맞춰줍니다. {위에서 누르면 짝이 맞는 }를 찾아주지요.

* Ctrl+L : 한줄을 잘라냅니다. -> 클립보드로

* Ctrl+Shift+L : 한줄을 지웁니다.

* Ctrl+J, K : #ifdef ... #endif 쌍을 찾는데 사용합니다.

* 그외 Ctrl을 누르고 커서나 Delete, Backspace를 누르면 단어 단위로 동작을 하게 됩니다.

* Alt+F8 : 인덴트 정리. 일정 범위를 선택하고 누르면 라인 앞부분의 공백을 자동으로 조정해줍니다.

* F2 나 Alt + F2 : 책갈피 기능이라고 생각하시면 됩니다. Alt + F2가 설정.. 그리고 F2가. 책갈피로 순차적 이동을 합니다.

변수이름을 적어 놓고 브래이크 포인터의 위치 여부와 관계 없이 변수의 내용을
추적하는 기능이 Watch Window에 들어 있죠...
그 때 디버그 모드에서 추가하고픈 변수나 등등 앞에 커서를 위치 시킨후
Shift + F9를 누르면 그냥 바로 추가됩니다

다른 툴도 마찬가지 이지만 VC++로 코딩 하다보면...
지우기는 애매하고, 그냥 두자니 Assert fail 나고 해서 주석 처리 해두고 지나가는
경우가 많습니다.
주석 처리할 코드가 한두 라인일 경우엔 간단하지만
여러 라인일 경우 // 로 처리하자니 너무 많아서 /* */를 쓰게 되는데...
별루 안 이쁘죠. 그리고 주석을 삭제할 때 많이 귀찮고...

자 이제 본론으로 들어가서 주석 처리용 매크로를 정해두고 쓰는 법을 갈쳐 드리겠습니다.

먼저 메뉴의 "Tools/Macro..."를 선택 합니다.
"Macro"라는 이름의 대화 상자가 뜨죠?
"Edit"를 누릅니다. 매크로 이름에 Comment라고 쓰시고 Description은 암꺼나 쓰던지
아님 비워 두시던지...
자 MYMACROS.DSM이란 파일이 뜨죠?

아래와 같이 코드를 복사해 넣습니다.

Sub Comment()
'DESCRIPTION: A description was not provided.

  Dim win
  set win = ActiveWindow
  if win.type <> "Text" Then
  MsgBox "This macro can only be run when a text editor window is active."
  else
  if InStr( ActiveDocument.Selection, vbCr ) > 0 then
  ActiveDocument.Selection.ReplaceText "^", "//", dsMatchRegExp
  Else
  ActiveDocument.Selection = "// " + ActiveDocument.Selection
  End If
  End If

End Sub

자 이제 창을 닫으세요. 저장하라면 "예"를 살포시 눌러 주시구...

다시 메뉴의 "Tools/Macro..."를 선택 해서 "Macro" 대화 상자를 엽니다.
다시 한번 "Edit"를 누릅니다. 매크로 이름에 Uncomment라고 쓰시고...
자 다시 MYMACROS.DSM이란 파일이 뜨죠?

아래의 코드를 또 복사해 넣습니다.

Sub UnComment()
'DESCRIPTION: A description was not provided.

  Dim win
  set win = ActiveWindow
  if win.type <> "Text" Then
  MsgBox "This macro can only be run when a text editor window is active."
  else
  ActiveDocument.Selection.ReplaceText "^//", "", dsMatchRegExp
  End If

End Sub

이제 창을 닫으시고... 저장 하시고...

마지막으로 메뉴의 "Tools/Macro..."를 선택 해서 "Macro" 대화 상자를 엽니다.
"Options >>" 버튼을 눌러서 추가된 버튼 중
"Keystrokes"를 누릅니다.

"Customize" 대화 상자가 열리죠?
거기서 "Macros/Comment"를 선택하고, "Press New Shortcut"을 선택한 다음
"Ctrl + /"를 눌러 줍니다. 입력창에 표시가 되죠?
이제 "Assign" 버튼을 눌러 입력을 종료하고...

다시 "Macros/Uncomment"를 선택하고, "Press New Shortcut"을 선택한 다음
"Ctrl + Shift + /"를 눌러 줍니다. 입력창에 표시를 확인 하신 후
"Assign" 버튼을 눌러 입력을 종료하고...

자 이제 모든 설정이 끝났습니다.
주석 처리를 하고 싶으신 부분을 선택하신 후 "Ctrl + /" 키를 누르면
선택된 라인 전체가 //로 주석 처리 될겁니다.
주석 처리된 라인을 선택한 후 "Ctrl + Shift + /"를 누르면
// 주석 처리가 사라지죠.

int var[5];
for(int i=0; j<5; i++) var[i] = 0;

코드를 보자.

여기에서 var 이란 변수의 크기 5 는 소스를 짜는 내내 개발자의 머릿속에 기억하고 있어야 한다.

그런데 머리가 필자처럼 나쁘다면????

이런 팁을 사용해보자.

#define arraylength(x) (sizeof(x) / sizeof(x[0]))

이 정의를 이용해서 위 코드를 다시 쓰면
for(int i=0; j<arraylength(var); i++) var[i] = 0;

var 에 대한 크기를 모를땐 저 매크로만 이용한다면 간단하게 컴파일러가 알려줄것이다...