C로 이미지,구조체등 바이너리 데이터를 MySQL에 담는 방법을 알아보자.  또한 C로 저장한 바이너리 데이터를 Flash에서 엑세스하는 법도 다루겠다.

이 글을 이해하려면 기본적으로 C와 ActionScript 3.0, Flex 4에 대해 알아야 한다. 그리고 예제에서 테스트한 C코드는 전부 이클립스+CDT+MinGW 환경에서 작업한 것들이다. 이런 환경을 구축해 본적이 없다면 다음 글을 참고한다.

  • Eclipse Galileo에서 C,C++ 개발환경 구축하기 - CDT, MinGW 
  • Eclipse, MinGW, CDT 환경에서 C/C++과 MySQL 연동



  • 1. Binary 타입 데이터를 DB에 저장하는 것에 대해
    바이너리(Binary) 타입의 데이터를 DB에 저장한다는 것은 가령, 이미지나 사운드와 같은 데이터를 DB에 저장한다는 의미로 해석하면 편하다.

    Binary파일을 DB에 넣을때 어떤 형태로 넣을 수 있을까? 

    한가지 예는 익히 잘 알고 있는 Base64로 치환해서 text형태로 넣는 방식을 생각해볼 수 있다. Base64는 ASCII코드로 화면에 출력할 수 있는 64개 문자(ABCD...89+/e등)을 이용해 Binary 데이터를 Text로 표현해준다. 하지만 이 방식의 단점은 데이타를 64진수로 표현한 문자열이기 때문에 용량이 필연적으로 커지고 또 encode/decode를 해야하는 부담이 존재한다. base 64에 대해서 알고 싶다면 다음 링크를 보자.

    Tistory에서 블로그 데이터 백업파일은 XML이다. 이 XML에 이미지와 같은 바이너리 파일은 담을 수 없으므로 Base64로 변형해 담게된다. 단지 대체하는 문자의 순서가 표준 방식인 ABCD...89+/e 순이 아니라 Vezh...식인 점이 다를 뿐이다. 참고로 아래 링크에 우야꼬님이 Flash로 컨버팅 해놓은 것이 있다.


    티스토리에서 백업기능을 왜 XML로 했을까? XML은 화면에 출력해볼 수 있는 언어이다. 화면에 출력할 수 없는 Binary보다는 훨씬 사용하기 쉽고 공유하기 쉽다.

    Base64는 아스키 시대의 유물이다. 요즘에는 pc에서 모바일까지 UTF8을 지원해주므로 이제 Base64에 의존하지 않고 Base256과 같은 것을 만들 수 있다. 이는 꽤 유용하다. 아래 hika님의 블로그를 보면 ActionScript 3.0으로 이와 관련된 글이 있다. 참고 바란다.


    하지만 Binary를 text로 decode/encode하는 과정이 반복되는 환경에 Base64와 같은 것을 적용하면 오히려 부담이 된다. 그러므로 필요하다면 Binary는 직접 Binary 자체를 저장하는 것이 좋겠다. 

    많은 DB에 BLOB(Binary Large OBject) 타입을 지원한다. 이 타입을 이용하면 DB에 어떤 형태의 Binary 데이타든지 넣을 수 있게 된다. 이 타입은 Text와 거의 동일하며 Binary 데이터를 넣을 수 있는 것만 다르다.

    아래는 인터넷에서 찾은 BLOB에 대해 설명이다.
    컴퓨터에서, BLOB[블랍]은 대체로 이미지나 사운드 파일과 같은 하나의 커다란 파일을 말하며, 그 크기 때문에 특별한 방법으로 다루어져야한다. 에릭 레이몬드에 따르면, BLOB에 관한 주요 아이디어는 DBMS와 같은 파일 처리기가 BLOB을 어떻게 처리할 것인가를 해결하기 위해 파일을 이해할 방법이 없다는 것이다. 다른 자료들에서는, 이 용어가 커다란 데이터 객체를 지칭하기 위해, 그리고 이러한 것들을 다룰 때 존재하는 문제점들을 암시하기 위해 만들어졌다고 강조한다. BLOB을 다루는 애플리케이션은 영화나 TV 프로그램 등과 같은 대형 멀티미디어 객체들의 데이터베이스 저장이다. BLOB은 이미지, 비디오, 사운드 등과 같은 멀티미디어 객체들을 저장하기 위해 주로 사용된다. 그러나 모든 DBMS가 BLOB을 지원하는 것은 아니다.

    컴퓨터 그래픽에서, blob(소문자로 쓴 BLOB)은 "재미있는 모양 형태"를 갖는 시각적 객체로서, 유연하고, 애니메이션을 따른다.

    일반적으로, blob은 무정형이며, 정의를 내리기 힘든 객체이다. UFO 연구에서는 물론, 천문학에도 blob이라는 것이 있다. "The Blob"이라는 제목의 과학 공상영화도 있었다.


    2. 이미지를 DB에 저장하기
    사실 Binary타입의 일종인 이미지(jpg,png등)를 DB에 저장하는 예제는 정말 많다(php에서 만큼은...). 그래서 굳이 여기에 예제를 적을 필요가 있겠냐만은.. 요즘 C를 이용해 다양한 시도를 하는 만큼, 이 부분도 적어본다.

    필자는 앞서 Eclipse기반에서 C/C++ 개발을 위한 환경만들기에 관련된 글을 적었다.

    아래에 소개할 예제들은 모두 위 글에서 언급한 환경에서 작성되었음을 밝힌다.

    간단히 이미지를 저장할 수 있는 테이블을 만들어보자. DB는 MySQL을 사용한다.
    mysql> describe images;
    +-------+------------+------+-----+---------+-------+
    | Field | Type       | Null | Key | Default | Extra |
    +-------+------------+------+-----+---------+-------+
    | id    | int(11)    | NO   | PRI |         |       |
    | data  | mediumblob | YES  |     | NULL    |       |
    +-------+------------+------+-----+---------+-------+
    2 rows in set (0.00 sec)
    


    위와 같은 구조의 테이블을 만들것이다. 다음 Create문으로 위 테이블을 생성한다.

    CREATE TABLE `images` (
      `id` int(11) NOT NULL auto_increment,
      `data` mediumblob,
      PRIMARY KEY  (`id`)
    ) ENGINE=MyISAM DEFAULT CHARSET=utf8

    테이블을 만들때 data field가 mediumblob라는 것에 주목하자. 참고로 MySQL에서 BLOB타입은 Tiny BLOB(255, 2^8-1 bytes), BLOB(65,535=2^16-1 bytes), Medium BLOB(16777215=2^16-1 bytes), Long BLOB(4294967295=2^32-1 bytes)등을 지원한다.

    다음은 임의 크기의 이미지를 불러와 제작한 테이블에 저장하는 C코드이다. (공개된 PHP코드는 많은데 이외로 C코드는 많이 없다.)
    #define SOCKET int
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <mysql/mysql.h>
    
    #define DB_HOST "localhost or ip or domain"
    #define DB_USER "DB 접속 ID"
    #define DB_PASS "DB 접속 password"
    #define DB_NAME "데이타베이스 이름"
    
    int main(void) {
    	MYSQL *connection, conn;
    	FILE *fp;
    	unsigned long len, file_size;
    	int query_stat;
    	char *buf , *buf_to, *query, *stat = "INSERT INTO images(data) VALUES('%s')";
    
    	//DB 초기화 및 접속
    	mysql_init(&conn);
    	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
    	if(connection==NULL) {
    		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
    		return EXIT_FAILURE;
    	} else {
    		printf("Mysql connected\n");
    	}
    
    	//이미지를 불러오기
    	fp = fopen("d:/image.png", "rb");
    	if(fp==NULL) {
    		fprintf(stderr, "image open error");
    		mysql_close(connection);
    		return EXIT_FAILURE;
    	}
    	rewind(fp);
    	fseek(fp,0,SEEK_END);
    	file_size = ftell(fp); //파일의 사이즈를 찾음
    	fseek(fp,0,SEEK_SET);
    	buf = (char*)malloc(file_size);
    	fread(buf, sizeof(char), file_size, fp); //파일을 읽어와 buf에 참고
    	fclose(fp);
    
    	//이미지내 escape string 적용
    	buf_to = (char*)malloc(file_size*2+1);
    	mysql_real_escape_string(connection, buf_to, buf, file_size); 
    
    	//Query 문 작성
    	query = (char*)malloc(strlen(stat)+file_size*2+1);
    	len = snprintf(query, strlen(stat)+file_size*2+1, stat, buf_to); 
    
    	//Query 문 실행
    	query_stat = mysql_real_query(connection, query, len); 
    	if(query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    	}
    
    	//할당한 메모리 반환
    	free(buf);
    	free(buf_to);
    	free(query);
    
    	//DB 커넥션 닫기
    	mysql_close(connection);
    	return EXIT_SUCCESS;
    }
    

    위 코드는 d:/image.png 를 로드해 DB 테이블에 insert 하는 과정을 보여주고 있다. 실제로 테스트가 완료되었고 잘 동작한다.

    mysql_real_escape_string() 함수는 바이너리 데이터를 insert하기 위해 SQL insert 문을 작성하는데 있어서 '\0'과 같은 문자가 들어가는 것을 방지해준다. SQL insert문은 텍스트 데이터로 작성되어야 하므로 '\0'과 같은 문자가 중간에 삽입되어 있으면 그것이 문자열의 종료를 의미하기 때문에 이 함수의 호출은 필연적이다.

    mysql_real_escape_string() 함수의 2번째 인자는 to, 3번째 인자는 from이다. 즉 from에서 '\0'과 같은 문자를 피하도록(escape) "\\0"등으로 치환해줘 그것이 to에서 참조되도록 하는 것이다. 이때 to의 사이즈는 from의 2배+1 이어야 한다.  buf_to = (char*)malloc(file_size*2+1); 문에서도 볼 수 있듯이 buf는 file_size의 크기를 가지는데 buf_to는 그의 2배+1로 메모리를 할당했다. 그 이유는 최악의 상황에서 escape처리할 문자가 from데이터의 2배가 될 수 있기 때문이다. 그리고 마지막 +1은 문자열의 마지막은 항상 '\0' 처리가 되어야 하므로 그 공간을 만들어주는 것을 의미한다.

    mysql_real_escape_string()에 대해서는 다음 링크를 참고한다.


    Query문을 작성하는데 있어서 snprintf() 함수를 이용했다. 이 함수는 printf나 sprintf와 용법이 비슷하게 문자열 치환 용도로 사용하는데 이 함수는 특별히 buffer 길이에 맞게 null문자까지 포함해 안전하게 복사해주는 기능을 가진다. 다음글을 참고하길 바란다.


    mysql_real_query() 함수는 바이너리 데이터를 포함한 Query를 수행하기 위해 사용한다. mysql_real_query에 대해서는 다음 링크를 참고한다.


    이제 저장한 이미지를 불려들어 saved-image.png로 파일에 저장해보자.


    #define SOCKET int
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <mysql/mysql.h>
    
    #define DB_HOST "localhost or ip or domain"
    #define DB_USER "DB 접속 ID"
    #define DB_PASS "DB 접속 password"
    #define DB_NAME "데이타베이스 이름"
    
    int main(void) {
    	MYSQL *connection, conn;
    	MYSQL_RES *result;
    	MYSQL_ROW row;
    	FILE *fp;
    	int query_stat;
    	unsigned long *lengths;
    
    	//DB 초기화 및 접속
    	mysql_init(&conn);
    	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
    	if(connection==NULL) {
    		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
    		return EXIT_FAILURE;
    	} else {
    		printf("Mysql connected\n");
    	}
    
    	//Query문 수행
    	query_stat = mysql_query(connection,"SELECT data FROM images WHERE id=1");
    	if(query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    		return EXIT_FAILURE;
    	}
    
    	//Query문 수행한 결과를 통해 데이터 참조
    	result = mysql_store_result(connection);
    	if(result == NULL) {
    		fprintf(stderr, "result is null\n");
    		return EXIT_FAILURE;
    	}
    	row = mysql_fetch_row(result);
    	lengths = mysql_fetch_lengths(result);
    	mysql_free_result(result);
    	printf("file lengths : %ld\n", lengths[0]);
    
    	//이미지 저장
    	fp = fopen("d:/savedImage.png", "wb");
    	if(fp==NULL) {
    		fprintf(stderr, "image save error");
    		mysql_close(connection);
    		return EXIT_FAILURE;
    	}
    	fwrite(row[0], lengths[0], 1, fp);
    	fclose(fp);
    
    	//DB 커넥션 닫기
    	mysql_close(connection);
    	return EXIT_SUCCESS;
    }
    
    코드를 보면 이미지를 insert하는 것보다 select하는게 오히려 쉽다. 실행후 마지막에 d:/savedImage.png가 있다면 성공한 것이다.


    3. 구조체를 DB에 저장하기
    대학시절 C언어의 구조체를 파일로 저장해본 경험이 있는가? 또 저장한 구조체를 다시 읽어 화면에 출력해본 적이 있는가? 이런 짓을 해봤다면 당신은 이미 DB에 구조체도 넣을 수 있다. 이 구조체도 일반 이미지와 같은 Binary파일이기 때문이다.

    이 방법은 일반 이미지를 DB에 넣어본 경험이 있는 분이라면 쉽게 이해할 수 있다.


    3.1 테스트 구조체 만들기

    저장할 구조체를 만들어보자. 개인정보를 담는 아주 간단한 구조체인 Personal을 만든다.

    #include <stdio.h>
    #include <stdlib.h>
    
    //#pragma pack(1) //struct member alignment를 1로 설정, 기본 설정이 8이라면 이것으로 20->19로 줄인다.
    typedef struct st_person {
    	unsigned __int16 user_id; //id, 2bytes 정수
    	char user_name[15]; //이름, 15bytes 캐릭터형
    	unsigned __int16 age; //나이, 2bytes 정수형
    
    }PERSON;
    //#pragma pack() //struct member alignment 원상복구
    
    int main(void) {
    	printf("struct PERSON size : %d\n",sizeof(PERSON));
    	return EXIT_SUCCESS;
    }
    


    분석할 것도 없다. 총 19bytes의 데이터를 담는 구조체를 만들었고 main함수에서 이 구조체의 크기를 출력한다.

    하지만 이 프로그램을 실행하면 실제 구조체 크기인 19bytes가 아닌 20bytes로 출력된다. 왜 그럴까 찾아보다가 발견한 것이 struct member alignment라는 용어였고 이것을 설정하는 코드중에 #pragma pack()이 있다는 것이다.

    위 코드에서 #pragma pack() 2부분 주석처리를 해제하고 다시 실행하면 19byte로 나온다. 19가 20로 된다는 것은 운영체제 별, 기본설정별로 전부 다르기 때문에 자세한 설명은 관련 내용을 찾아보길 바란다.

    필자는 DB에 저장시에 하나의 Field에 여러명의 Personal 정보를 넣는것을 목적으로 하기 때문에 1~2bytes 차이가 저장되는 사람의 숫자만큼 증가되는 문제가 생길 수 있다. 이런 경우에 #pragma pack()을 적절히 사용하면 남는 공간을 줄일 수 있다.

    #pragma pack는 온라인 게임이나 네트워크 프로그램에서 이기종간 통신 간 패킷단위를 struct로 정의해 통신하는 경우에 유용하다. 그리고 사용시 주의 사항도 있으므로 이에 대해서는 더욱 학습이 필요하다.


    3.2 구조체를 담을 DB 테이블 제작

    위 구조체를 담을 DB 테이블은 다음 쿼리로 만들면 되겠다.


    CREATE TABLE `persons` (
      `AREA` int(11) NOT NULL auto_increment,
      `COUNT` smallint(5) unsigned default NULL,
      `DATA` blob NOT NULL,
      PRIMARY KEY  (`AREA`)
    ) ENGINE=MyISAM DEFAULT CHARSET=utf8
    


    area가 key값이고 area별로 사람들의 데이터가 data에 담긴다. 이 data는 여러명의 데이터가 담겨질 것이다. 아마도 이게 유용한거냐?라는 질문을 한다면 이것은 한가지 예일 뿐이고 필자는 실제로 유용한 방법이였다. ^^


    3.3 구조체 포인터 배열을 만들어 DB에 저장하고 읽어오기
    구조체를 DB 테이블에 저장하는 것은 이미지를 저장할때와 별반 다른 것이 없다. 위에서 제시한 구조체로 이루어진 데이터의 경우가 특별할 것 같지만 실제로는 똑같다. 구조체를 만들때 user_id, user_name, age 순으로 만들었기 때문에 각각 2+15+2 = 19바이트가 1개의 개인정보 바이너리 데이터가 된다. 만약 2명이면 19x2=38 바이트의 바이너리 데이터가 되는 것이다. 이 모든 것을 수행하는 간단한 코드는 다음과 같다.


    #define SOCKET int
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <memory.h>
    #include <string.h>
    #include <mysql/mysql.h>
    
    #define DB_HOST "localhost or ip or domain"
    #define DB_USER "DB 접속 ID"
    #define DB_PASS "DB 접속 password"
    #define DB_NAME "데이타베이스 이름"
    
    #define TABLE_NAME "persons"
    #define SQL_DROP_TABLE "DROP TABLE IF EXISTS %s"
    #define SQL_CREATE_TABLE "CREATE TABLE `%s` (\
    `AREA` int NOT NULL AUTO_INCREMENT,\
    `COUNT` smallint unsigned,\
    `DATA` BLOB NOT NULL,\
    PRIMARY KEY(`AREA`)\
    ) ENGINE=MyISAM DEFAULT CHARSET=utf8"
    #define SQL_INSERT_DATA "INSERT INTO %s(DATA,COUNT) values('%s',%d)"
    #define SQL_SELECT_DATA "SELECT `DATA`, `COUNT` FROM %s WHERE `AREA`=%d"
    
    #pragma pack(1) //struct member alignment를 1로 설정, 기본 설정이 8이라면 이것으로 20->19로 줄인다.
    typedef struct st_person {
    	unsigned __int16 user_id; //id, 2bytes 정수
    	char user_name[15]; //이름, 15bytes 캐릭터형
    	unsigned __int16 age; //나이, 2bytes 정수형
    
    }PERSON;
    #pragma pack() //struct member alignment 원상복구
    
    int connect();
    int close();
    int create_table();
    int drop_table();
    PERSON* add_data(PERSON *person_list, int index, unsigned __int16 user_id, unsigned __int16 age, char* user_name);
    int remove_all_data(PERSON* person_list);
    int insert_data(PERSON* person_list, int count);
    int select_data(int area);
    
    MYSQL *connection, conn;
    
    int main(void) {
    	printf("PERSON struct size : %d\n",sizeof(PERSON));
    	connect();
    	drop_table();
    	create_table();
    
    	PERSON *person_list;
    	person_list = add_data(NULL,0,1,30,"jidolstar");
    	person_list = add_data(person_list,1,2,22,"joykim");
    	person_list = add_data(person_list,2,3,2,"tae hyun");
    	insert_data(person_list,3);
    	free(person_list);
    	select_data(1);
    
    	person_list = add_data(NULL,0,4,30,"addlayer");
    	person_list = add_data(person_list,1,5,22,"eye");
    	person_list = add_data(person_list,2,6,2,"unclejoe");
    	person_list = add_data(person_list,3,7,3,"miracle");
    	insert_data(person_list,4);
    	free(person_list);
    	select_data(2);
    
    
    	close();
    	return EXIT_SUCCESS;
    }
    
    /**
     * DB 접속
     */
    int connect() {
    	// mysql 초기화
    	mysql_init(&conn);
    
    	// DB 연결
    	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306, (char*)NULL, 0);
    	if(connection==NULL) {
    		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
    		exit(0);
    	} else {
    		printf("Mysql connected\n");
    	}
    	return 0;
    }
    /**
     * 데이타 베이스 닫음
     */
    int close() {
    	mysql_close(connection);
    	printf("mysql closed\n");
    	return 1;
    }
    
    /**
     * 테이블 생성
     */
    int create_table() {
    	int query_stat;
    	char buff[1024];
    
    	memset(buff,0x00,sizeof(buff));
    	sprintf( buff, SQL_CREATE_TABLE, TABLE_NAME );
    	query_stat = mysql_query(connection,buff);
    	if( query_stat != 0 ) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    		exit(0);
    	} else {
    		printf("created table\n");
    	}
    	return 0;
    }
    
    /**
     * 기존 테이블 삭제
     */
    int drop_table() {
    	int query_stat;
    	char buff[1024];
    
    	//기존 테이블 삭제
    	memset(buff,0x00,sizeof(buff));
    	sprintf( buff, SQL_DROP_TABLE, TABLE_NAME );
    	query_stat = mysql_query(connection,buff);
    	if( query_stat != 0 ) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    		exit(0);
    	} else {
    		printf("table dropped\n");
    	}
    	return 0;
    }
    
    /**
     * 데이터 추가
     */
    PERSON* add_data(PERSON *person_list, int index, unsigned __int16 user_id, unsigned __int16 age, char* user_name) {
    	PERSON *current;
    	if(person_list == NULL ) {
    		person_list = (PERSON*)malloc(sizeof(PERSON));
    		current = person_list;
    	} else {
    		person_list = (PERSON*)realloc(person_list, sizeof(PERSON)*(index+1));
    		current = person_list + index;
    	}
    	current->user_id = user_id;
    	current->age = age;
    	memset(current->user_name,0x00,sizeof(current->user_name));
    	strcpy(current->user_name,user_name);
    	//printf("added user_id:%d, age:%d, name:%s\n",current->user_id,current->age,current->user_name);
    	return person_list;
    }
    
    /**
     * 모든 데이터 삭제
     */
    int remove_all_data(PERSON* person_list) {
    	free(person_list);
    	return 0;
    }
    
    /**
     * 데이타를 디비 테이블에 삽입
     */
    int insert_data(PERSON* person_list, int count) {
    	int query_stat;
    	unsigned long len, size;
    	char *buf_to, *query;
    
    	size = sizeof(PERSON)*count*2+1;
    	buf_to = (char*)malloc(size);
    	mysql_real_escape_string(connection, buf_to, (char*)person_list, sizeof(PERSON)*count);
    
    	//Query 문 작성
    	query = (char*)malloc(sizeof(SQL_INSERT_DATA)+size);
    	len = snprintf(query, sizeof(SQL_INSERT_DATA)+size, SQL_INSERT_DATA, TABLE_NAME, (char*)buf_to, count );
    
    	//Query 문 실행
    	query_stat = mysql_real_query(connection, query, len);
    	if(query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    	} else {
    		printf("insert complete\n");
    	}
    
    	//할당한 메모리 반환
    	free(buf_to);
    	free(query);
    	return 0;
    }
    
    /**
     * 데이타를 디비에서 읽어옴
     */
    int select_data(int area) {
    	char query[1024];
    	int query_stat;
    	int count=0;
    	int i;
    	PERSON *person_list, *person;
    	MYSQL_RES *result;
    	MYSQL_ROW row;
    
    	memset(query,0x00,sizeof(query));
    	sprintf(query, SQL_SELECT_DATA, TABLE_NAME, area);
    	query_stat = mysql_query(connection,query);
    	if(query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s\n", mysql_error(&conn));
    		exit(0);
    	}
    
    	//갯수만큼 화면에 데이터 출력
    	result=mysql_store_result(connection);
    	row = mysql_fetch_row(result);
    	mysql_free_result(result);
    	count = atoi(row[1]); //갯수
    	person_list = (PERSON*)row[0]; //한개의  데이터
    	for( i=0; i<count; i++ ) {
    		person = person_list + i;
    		printf("user_id:%d, age:%d, name:%s\n",person->user_id,person->age,person->user_name);
    	}
    	free(person_list);
    	return 0;
    }
    

    위 코드를 천천히 분석하면 어떻게 구조체 정보를 데이타베이스에 저장하고 읽어올 수 있는지 어렵지 않게 분석할 수 있을 것이다. 코드 자체는 연습용으로 급조된 거라서 중간중간 엉성한 부분은 그냥 넘어가자 ^^


    4. ActionScript 3.0으로 바이너리 데이터 읽어오기 

    필자가 C를 지금까지 파고 든 가장 큰 목적은 Flash에서 C로 저장된 구조체 데이터를 읽어오는 것에 있다. ActionScript 3.0 API에는 바이너리 데이터를 다룰 수 있는 강력한 클래스가 존재한다. 그것은 ByteArray이다. 이 ByteArray를 이용하면 구조체 바이너리 데이터를 아주 쉽게 사용할 수 있게 된다.

    DB에 저장된 바이너리 데이터를 Java로 로드해 AMF로 flash로 전송해주고 Flash에서는 이 데이터를 해석해 사용한다.

    자바에서 해당 데이터를 로드할 때 변환되는 Value Object의 형태는 다음과 같을 것이다.
    package com.jidolstar.person.domain;
    
    public class PersonArea {
    	private int area;
    	private int count;
    	private byte[] data;
    	
    	public int getArea() {
    		return area;
    	}
    	public void setArea(int area) {
    		this.area = area;
    	}
    	public int getCount() {
    		return count;
    	}
    	public void setCount(int count) {
    		this.count = count;
    	}
    	public byte[] getData() {
    		return data;
    	}
    	public void setData(byte[] data) {
    		this.data = data;
    	}
    }
    


    위 자바객체를 BlazeDS나 LCDS를 이용해 AMF(ActionScript Message Format)으로 전송하면 Flex나 ActionScript 3.0에서 직렬화되는 객체는 다음과 같을 것이다.
    package {
    	import flash.utils.ByteArray;
    
    	[RemoteClass(alias="com.jidolstar.person.domain.PersonArea")]
    	public class PersonArea	{
    		public var area:int;
    		public var count:int;
    		public var data:ByteArray;
    	}
    }
    


    위 클래스에서 자바에서 AMF로 넘겨주는 PersonArea를 직렬화 처리하기 위해 [RemoteClass(alias="com.jidolstar.person.domain.PersonArea")] 를 사용했다는 것에 주목하자. 또한 자바의 byte[] 포멧은 ActionScript 3.0의 ByteArray로 직렬화 처리된다.

    우리는 최종적으로 다음 ActionScript 3.0 클래스로 변환되기를 희망한다.

    package {
    	public class AreaDetail {
    		public var area:int;
    		public var id:int;
    		public var name:String;
    		public var age:int;
    	}
    }
    


    다음 코드는 이를 진행해 줄 Flex 4 코드이다.
    <?xml version="1.0" encoding="utf-8"?>
    <s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
    			   xmlns:s="library://ns.adobe.com/flex/spark" 
    			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600" 
    			   xmlns:halo="library://ns.adobe.com/flex/halo">
    	<fx:Declarations>
    		<s:RemoteObject id="ro" destination="personRO">
    			<s:method name="getPersonArea" result="result_handler(event)" fault="mx.controls.Alert.show(event.fault.faultString)"/> 
    		</s:RemoteObject>
    		<s:ArrayCollection id="ac"/>
    	</fx:Declarations>
    	<fx:Script>
    		<![CDATA[
    			import mx.collections.ArrayCollection;
    			import mx.controls.Alert;
    			import mx.rpc.events.ResultEvent;
    			
    			private function result_handler($event:ResultEvent):void {
    				var personArea:PersonArea = $event.result as PersonArea;
    				var count:int = personArea.count;
    				var person:PersonDetail;
    				var data:ByteArray = personArea.data;
    				var area:int = personArea.area;
    				ac.removeAll();
    				data.endian = Endian.LITTLE_ENDIAN; //구조체로 저장된 데이터가 little endian인 경우 이 설정을 해야한다.//http://blog.naver.com/kimsumin75/20055881438
    				ac.disableAutoUpdate();
    				while( count-- ) {
    					person = new PersonDetail;
    					person.area = area;
    					person.id = data.readShort()
    					person.name = data.readUTFBytes(15,"utf-8");
    					person.age = data.readShort();
    					//trace(data.readByte()); //만약 c에서 #progma pack(1)을 사용하지 않았다면 19가 아닌 20바이트가 넘어올 것이므로 1바이트가 비게 된다. 이때는 이 부분의 주석이 풀어져야 제대로 읽어올 수 있다.
    					ac.addItem(person);
    				}
    				ac.enableAutoUpdate();
    				ac.refresh();
    			}
    
    			protected function button1_clickHandler(event:MouseEvent):void
    			{
    				ro.getPersonArea(parseInt(tiArea.text));
    			}
    
    		]]>
    	</fx:Script>
    	<halo:Form x="10" y="7" width="225" height="132">
    		<halo:FormItem label="area">
    			<s:TextInput id="tiArea" text="1"/>
    		</halo:FormItem>
    		<s:Button label="불러오기" click="button1_clickHandler(event)"/>
    	</halo:Form>
    	<halo:DataGrid x="243" y="10" height="360" width="385" dataProvider="{ac}">
    		<halo:columns>
    			<halo:DataGridColumn headerText="AREA" dataField="area"/>
    			<halo:DataGridColumn headerText="ID" dataField="id"/>
    			<halo:DataGridColumn headerText="NAME" dataField="name"/>
    			<halo:DataGridColumn headerText="AGE" dataField="age"/>
    		</halo:columns>
    	</halo:DataGrid>
    </s:Application>
    


    위 코드에서 중요한 부분은 result_handler() 메소드 부분이다. ByteArray로 직렬화되어 들어온 데이터를 어떻게 읽어들이고 사용하는지 보여주고 있다. 중요한 것은 구조체의 정의시 user_id, user_name, age순으로 했기 때문에 ByteArray로 읽을때도 그와 같은 순으로 읽어야 하며 각각 읽어들일때 Byte도 잘 따져야 한다. 각각 2, 15, 2 바이트씩 총 19바이트를 저장했기 때문에 ByteArray에서 2바이트 정수를 읽어주는 readShort()메소드를 사용했다. 또한 문자열을 읽기 위해 readUTFBytes()를 이용했다.

    //trace(data.readByte()); 으로 주석된 부분이 있다. 이 부분은 c코드에서 #progma pack(1)으로 처리하지 않았을때 구조체의 크기는 19바이트가 아닌 20바이트가 되므로 ByteArray로 읽을때 항상 1바이트가 남게된다. 그러므로 c코드에서 #progma pack(1)가 꼭 필요하다는 것을 여기서도 알 수 있다. 

    마지막으로 ByteArray를 읽기전에 data.endian = Endian.LITTLE_ENDIAN 처리를 했다. Endian의 종류는 두가지이다. Big Endian과 Little Endian이다. 이것은 데이타를 메모리에 쓰는 방식의 차이로 필자가 c코드를 돌려 구조체를 저장할때 방식이 Little Endian방식으로 저장했기 때문에 ByteArray로 넘어온 데이타도 그렇게 읽을 수 밖에 없게 된다. 이 방식의 차이와 장단점은 아래 링크를 통해 살펴보길 바란다.

    Big Endian과 Little Endian


    5. 정리하며

    바이너리 데이터를 데이타 베이스에 저장하고 최종적으로 Flash기반에서 로드하는 것까지 다뤄봤다. 꽤 많은 내용을 다룬 것 같지만 실상은 매우 단순하다. 바이트 단위로 데이타를 이해한다면 그리 어렵지 않은 내용들이며 결국 이런 처리를 익숙하게 할 수 있겠는가가 중요한 것 같다.

    필자는 ActionScript나 Java등에 익숙하다 보니 이들 언어에서 메모리 관리등을 모두 다 해주니깐 게을러지는 것 같다. 이들 언어를 하더라도 c언어는 꾸준히 해주어야하고 종종 실무에도 적용해줘야겠다.

    글쓴이 : 지돌스타(http://blog.jidolstar.com/681)
    Eclipse에서 CDT 플러그인과 MinGW에서 지원하는 C/C++ 컴파일러를 통해 개발하는 방법에 대해서 소개했었다.
    Eclipse Galileo에서 C,C++ 개발환경 구축하기 - CDT, MinGW

    참고로 오래전에 MS Visual Studio 환경에서 MySQL과 연동하는 방법과 ActionScript 3.0 으로 만들어진 MySQL Driver에 대해 소개한 적이 있다.
    MS Visual C++ 6.0 환경에서 MySQL 연동하는 방법
    Actionscript 3 Mysql Driver

    이 글은 Eclipse + MinGW 환경에서 C/C++로 MySQL과 연동하는 방법을 소개한다. MySQL 연동을 위해서 Eclipse환경을 선택한 이유는 기존 프로젝트들이 Java, Flash 로 제작되어서 하나의 툴에서 개발하고 싶은 욕구가 있기 때문이다. 하나의 Eclipse로 Java, PHP, C/C++, Flash 개발을 다할 수 있기 때문에 지원하는 각종 플러그인을 함께 공유할 수 있고 툴을 이리저리 이동할 필요도 없어진다.

    Eclipse와 MinGW으로 개발환경을 구축한 만큼 그에 맞게 개발방식을 알아야 할 것이다.


    1. MinGW Utils 설치

    MinGW에서 지원하는 Utils을 다운로드 받아서 설치해야 한다. 이것이 필요한 이유는 reimp.exe 가 필요하기 때문이다. 자세한 내용은 다음에 설명한다.

    다음 링크로 들어가서 아래 리스트에 MinGW Utilities > mingw-utils > mingw-utils-0.3 로 가면 mingw-utils-0.3.tar.gz 파일이 있다. 이것을 다운로드 받는다.

    http://sourceforge.net/projects/mingw/files/

    압축을 풀면 bin, doc 폴더가 있는데 이 두개 폴더를 복사해서 MinGW 설치폴더에 덮어씌우면 된다. 그것으로 설치 끝이다.


    2. MySQL 라이브러리 설치
    MySQL 서버가 이미 설치가 되어 있는 경우라고 가정한다. 일단 다음 링크로 가서 MySQL MSI 설치자를 다운로드 받는다.

    http://dev.mysql.com/downloads/mysql

    다운로드 받은수 설치시에 아래와 같은 Setup Type을 묻는 내용이 나오면 custom을 선택한다.

    MySQL이 이미 설치되어 있거나 어떠한 경로라도 접속할 수 있는 환경이 이미 조성되어 있는 경우에는 Server를 굳이 설치할 필요가 없으므로 아래처럼 C개발시 필요한 파일만 설치가 되도록 설정한다.

    아마도 C:/Program Files/MySQL/MySQL Server 5.1/ 내에 설치될 것이다. 그 안에는 include와 lib만 존재할 것이다. include는 c언어의 header 파일들이 존재할 것이다. 그리고 lib에는 MySQL에 접속하기 위한 각종 Lib파일들이 존재한다.


    3. MySQL 연동을 위한 MinGW 컴파일러 라이브러리로 만들기
    MySQL설치 폴더에 lib/opt/libmysql.lib 가 있다. 이것은 MySQL을 접속하기 위한 구현체 정의가 담겨있다. C,C++로 개발할 때는 이것을 참조해서 개발하고 컴파일해야 할것이다.

    하지만 MinGW에서 제공하는 컴파일러는 .lib를 직접 사용할 수 없다. 그래서 대신 확장자가 .a인 MinGW 전용의 라이브러리로 변경해야하는데 앞서 소개한 MinGW Utils에 reimp.exe와 dlltool.exe가 그것을 가능하게 해준다.

    먼저 CMD 창에 들어가서 다음과 같이 입력해본다.

    C:\>cd C:/Program Files/MySQL/MySQL Server 5.1/lib/opt
    C:\>reimp -d libmysql.lib
    C:\>dlltool -d LIBMYSQL.def -D libmysql.dll -k -l libmysql.a

    위처럼 명령후 opt 폴더안에 libmysql.a가 있는지 확인한다. 만약 없다면 opt폴더를 c:\ 하위로 옮겨보고 그 안에서 위 명령을 다시 해보길 바란다.

    reimp -d libmysql.lib 는 LIBMYSQL.def를 만들어내는데 이것을 열어보면 라이브러리에 정의된 함수가 쭉 나열되어 있음을 확인할 수 있다. dlltool 은 이것을 이용해 libmysql.a를 뽑아낸다.

    libmysql.a는 복사해서 MinGW의 lib폴더에 복사한다.

    그리고 MySQL 설치폴더에 include은 mysql로 수정하고 MinGW의 include 내에 복사하면 아래처럼 사용할 수 있게 된다.

    #include <mysql/mysql.h>


    5. Eclipse에서 C프로젝트를 생성해 MySQL 접속해보기
    이제 C로 MySQL에 접속하기 위한 준비는 완료했다. 이제 C프로젝트를 만들고 MySQL 접속하기 위한 간단한 예시를 만들어보자. File>New>C Project를 아래처럼 생성한다.



    Project Explorer에 MySQLTest 프로젝트가 만들어졌을 것이다. src 폴더를 열어 MySQLTest.c를 다음 코드로 수정하자.


    #define SOCKET int
    
    #include <stdio.h>
    #include <mysql/mysql.h>
    
    #define DB_HOST "localhost 또는 아이피, 도메인"
    #define DB_USER "DB 사용자 ID"
    #define DB_PASS "DB 사용자 Password"
    #define DB_NAME "DB 이름"
    
    int main() {
    	MYSQL *conn_ptr;
    	conn_ptr = mysql_init(NULL);
    	if(!conn_ptr) {
    		printf("mysql_init failed!!\n");
    		return 0;
    	}
    
    	conn_ptr = mysql_real_connect(conn_ptr, DB_HOST, DB_USER, DB_PASS, DB_NAME, 3306,(char *)NULL, 0);
    
    	if(conn_ptr) {
    		printf("연결이 성공 되었습니다.\n");
    	} else {
    		printf("연결에 실패했습니다.\n");
    	}
    	mysql_close(conn_ptr);
    	return 1;
    }
    
    

    코드를 만들었으니 이제 MySQL 라이브러리를 사용한다는 컴파일 옵션을 주어야 한다. 방법은 다음과 같이 하면 되겠다.

    이클립스 메뉴에서 Project > Properties로 들어간다. C/C++Build > Setting으로 들어가 Tool Setting 탭으로 누른다. 다음으로 MinGW C Linker > Libraries를 선택한다. 아래처럼 mysql을 등록한다. 이렇게 하면 컴파일시 -lmysql로 옵션을 주는 것과 같아진다.


    Ctrl+B나 메뉴>Project>Build All을 선택해서 컴파일 해보자. 다음과 같처럼 컴파일이 정상적으로 나왔다면 성공한 것이다. 
     

    **** Build of configuration Debug for project MySQLTest ****

    **** Internal Builder is used for build               ****
    gcc -O0 -g3 -Wall -c -fmessage-length=0 -osrc\MySQLTest.o ..\src\MySQLTest.c
    gcc -oMySQLTest.exe src\MySQLTest.o -lmysql
    Build complete for project MySQLTest
    Time consumed: 578  ms. 

    Ctrl+F11이나 Run > Run 을 해보자. 콘솔창에 아래처럼 나오면 성공한 것이다.


    만약 위처럼 아무 메시지 없이 실행되지 않는 것처럼 보인다면 C:/Windows/System32 내에 libmysql.dll이 없는 것을 의심해본다.

    실제로 CMD창을 열고 프로젝트의 Debug안에 있는 MySQLTest.exe를 CMD 창에 드래그해 붙여넣은 다음 Enter를 눌러 실행해보자. 아래처럼 "연결이 성공 되었습니다"라고 보이지 않고 그 아래처럼 libmysql.dll이 없다고 나오면 아래서 소개하는 두가지 방법으로 해결할 수 있다.



    일단 libmysql.dll 이 있다고 가정한다면 아래 둘중에 하나를 선택해서 하면 된다.

    1. libmysql.dll을 C:/windows/System32에 복사한다.
    2. 프로젝트의 Debug폴더나 Release폴더(즉, exe 실행파일과 같은 경로)에 libmysql.dll을 복사한다.


    dll과 함께 컴파일 처리하면 좋겠는데 아직 방법은 모르겠다.

    libmysql.dll을 얻는 방법은 http://www.dll-files.com/ 에 접속해 libmysql.dll을 찾는다. libmysql.dll을 다운로드 받을 수 있는 페이지가 나오면 다른거 누르지 말고 아래 그림과 같은 Free download의 Download 버튼을 눌러 다운로드 받는다.



    6. 테이블 생성, 선택, 삽입, 편집, 삭제 해보기
    접속까지 했으니 응용하는 것은 누워서 떡먹기다. Create table, Select, Insert, Update, Delete 예제는 다음과 같다.

    #define SOCKET int
    
    #include <stdio.h>
    #include <mysql/mysql.h>
    
    #define DB_HOST "localhost 또는 아이피, 도메인"
    #define DB_USER "DB 사용자 ID"
    #define DB_PASS "DB 사용자 Password"
    #define DB_NAME "DB 이름"
    
    #define SQL_CREATE_TABLE "CREATE TABLE `mysql_api_test` (\
        `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,\
        `num` INT NULL ,\
        `string` VARCHAR( 20 ) NULL \
        ) TYPE = MYISAM ;"
    #define SQL_INSERT_RECORD "INSERT INTO `mysql_api_test` ( `id` , `num` , `string` ) \
        VALUES (\
        NULL , '%d', '%s'\
        );"
    #define SQL_SELECT_RECORD "SELECT * FROM `mysql_api_test`"
    #define SQL_DROP_TABLE "DROP TABLE `mysql_api_test`"
    
    int main() {
    	MYSQL *connection=NULL, conn;
    	MYSQL_RES *sql_result;
    	MYSQL_ROW sql_row;
    	int query_stat;
    	int i;
    
    	char query[255];
    
    	mysql_init(&conn);
    
    	// DB 연결
    	connection = mysql_real_connect(&conn, DB_HOST, DB_USER, DB_PASS,DB_NAME, 3306,(char *)NULL, 0);
    	if(connection==NULL) {
    		fprintf(stderr, "Mysql connection error : %s", mysql_error(&conn));
    		return 1;
    	}
    
    	// 테이블 생성
    	query_stat=mysql_query(connection,SQL_CREATE_TABLE);
    	if (query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s", mysql_error(&conn));
    		return 1;
    	}
    
    	// 레코드 삽입
    	for(i=0;i<5;i++) {
    		sprintf(query,SQL_INSERT_RECORD,100+i,"안녕하세요 지돌스타예요~");
    		query_stat = mysql_query(connection, query);
    		if (query_stat != 0) {
    			fprintf(stderr, "Mysql query error : %s", mysql_error(&conn));
    			return 1;
    		}
    	}
    
    	// 셀렉트
    	query_stat=mysql_query(connection,SQL_SELECT_RECORD);
    	if (query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s", mysql_error(&conn));
    		return 1;
    	}
    
    	// 결과 출력
    	sql_result=mysql_store_result(connection);
    	while((sql_row=mysql_fetch_row(sql_result))!=NULL) {
    		printf("%2s %2s %s\n",sql_row[0],sql_row[1],sql_row[2]);
    	}
    	mysql_free_result(sql_result);
    
    	// 테이블 삭제
    	query_stat=mysql_query(connection,SQL_DROP_TABLE);
    	if (query_stat != 0) {
    		fprintf(stderr, "Mysql query error : %s", mysql_error(&conn));
    		return 1;
    	}
    
    	// DB 연결 닫기
    	mysql_close(connection);
    	return 0;
    }
    
    

    7. 정리하며
    이미 많은 분들이 삽질(?)을 많이 해주셔서 비교적 쉽게 MySQL 개발 환경을 조성할 수 있었다. 뭔가 이런 환경에서 개발한다면 크로스 플랫폼 애플리케이션을 만드는데 도움이 될 것 같다. 관련된 정보를 찾아봐서 개발방법에 대해서 좀더 숙지해야할 필요가 있을 것 같다.


    8. 참고글
    Eclipse Galileo에서 C,C++ 개발환경 구축하기 - CDT, MinGW
    MS Visual C++ 6.0 환경에서 MySQL 연동하는 방법
    VC용 lib화일을 mingw용 라이브러리로 변환하기
    MinGW로 Mysql plugin driver compile하는 방법
    DLL 다운받기


    글쓴이 : 지돌스타(http://blog.jidolstar.com/679)

    윈도우 환경에서 Eclipse Galileo 버전으로 C, C++ 개발을 위한 환경을 만드는 것을 설명하는데 목표가 있다. 기존에 Eclipse기반으로 Flash Builder 플러그인을 설치해 Flash 개발을 하거나 Java 개발하시는 분들이 같은 환경에서 C, C++을 개발하고자 한다면 이 글은 유용한 팁정도가 될 것이다.


    1. MinGW를 설치한다.
    MinGW(한국어 발음 밍우?)는 무료로 쓰고 배포할 수 있는 MS 윈도우 헤더 파일과 라이브러리로, 어떠한 써드 파티 C 런타임 DLL에 의존하지 않고 네이티브 윈도우 프로그램을 만들 수 있는 GNU 툴을 제공한다. 쉽게 이야기해 MinGW는 윈도우에서 툴이나 dll에 의존하지 않는 동작하는 프로그램을 만들 수 있도록 도와준다.

    MinGW에 대해 : http://ko.wikipedia.org/wiki/MinGW 

    물론 C/C++를 개발하기 위해 Cygwin을 이용해도 된다. 하지만 cygwin 기반으로 제작한 것은 항상 cygwin1.dll이 필요한다. 또한 개발한 결과물은 라이센스 문제로 상용으로 팔기가 곤란하다. 게다가 윈도우에서 직접 개발한다기 보다 가상의 리눅스 콘솔을 이용하는 것이다. 그래서 여러가지로 MinGW이 장점이 많다.


    1.1 MinGW 받기
    공식 사이트 http://www.mingw.org/ 로 간다. 좌측 메뉴에 Downloads 페이지로 이동한다. Download Now 버튼을 눌러 최신버전인 MinGW-5.1.6.exe(2010.04.20)를 다운로드 받는다.


    1.2 MinGW 설치
    • 다운받은 MinGW-5.1.6.exe를 실행한다.
    • Welcome 화면 Next를 클릭한다.
    • Download and install을 선택후 Next 버튼을 클릭한다.
    • I agree를 클릭한다.
    • Candidate를 선택후 Next를 클릭한다.
    • 설치하고자 하는 것을 선택후 Next를 클릭한다. g++ compiler와 MinGW Make는 반드시 선택한다.
    • 설치하고자 하는 디렉토를 선택한 다음 Next 클릭
    • Install을 클릭하면 이제 필요한 것을 다운로드 받아 설치를 시작한다.
    • 설치가 완료되면 Next 클릭후 Finish를 누른다.

     

    1.3 GCC를 실행하기 위한 윈도우 환경변수 설정하기

    이제 어느 경로에 있던지 gcc 컴파일러를 실행할 수 있도록 환경을 조성해줄 필요가 있다.

    이 방법은 Cygwin을 사용하지 않고 오로지 MinGW만 사용하는 경우에 해당한다. 만약 Cygwin을 함께 사용하시는 분이라면 배치파일을 만들어 사용하는 방법도 있다. (http://kldp.org/node/48962)

    • 제어판에서 시스템 폴더 클릭. window 7환경에서 개발한다면 검색창에서 시스템을 입력한뒤 시스템 환경 변수 편집을 선택한다.
    • 아래 표시된 방법대로 입력하면 되겠다. 최종적으로 MinGW 설치된 폴더에 Bin 폴더를 입력하는 것을 목표로 한다.


    • CMD창에서 gcc --version과 mingw32-make를 입력하고 다음과 같이 나오면 성공적으로 설치된것임

     이제 MinGW가 설치되었으므로 window 기반에서 C, C++등을 개발할 수 있는 환경이 만들어진 것이다. 다음에 나오는 Eclipse기반이 아니더라도 메모장에서 C코드를 짜고 GCC로 컴파일할 수 있다. 하지만 개발툴을 메모장을 사용할 수는 없는 노릇아닌가?


    2. Eclipse Galileo 버전을 설치한다.
    Eclipse는 기존에 설치했던 사람이 대부분일 것이다. 이 설명은 필요없는 내용일 수 있으나 그냥 적어본다.

    일단 Eclipse는 아래 링크에서 자신의 개발하고자 하는 목적별(Java, C/C++, PHP등)로 다운로드 받아 설치할 수 있다.

    http://www.eclipse.org/downloads/

    필자는 Java기반에서 개발하는 일이 많으므로 Java EE Developers를 위한 Eclipse IDE를 설치했다. Windows 32bit 기반을 다운로드 받았다. 설치는 받은 압축파일을 원하는 곳에 압축만 풀어주는 것으로 완료가 된다. 본인은 E:\eclipse 에 설치했다. C 드라이브에 설치하지 않은 이유는 나중에 운영체제를 다시 설치하는 경우에 Eclipse를 보존하기 위함이다.

    Eclipse를 처음 설치하는 사람이라면 반드시 JRE가 자신의 컴퓨터에 미리 설치가 되어 있어야 Eclipse 구동이 가능하다. 다음 링크에서 JRE나 JDK 최신버전을 설치하면 되겠다.

    http://java.sun.com/javase/downloads/index.jsp

    만약 C/C++기반인 Eclipse를 다운로드 받아 설치하면 다음에 "3. CDT 플러그인을 설치한다"를 넘겨도 된다.


    3. CDT 플러그 인을 설치한다.

    CDT는 C/C++ Development Tool이다. 기존에 이클립스 기반으로 개발하던 사람이라면 C/C++도 Visual Studio와 같은 툴을 활용하지 않고 개발하고자 하는 욕구(?)가 들지도 모르겠다. CDT를 Eclipse에 설치하면 C,C++ 개발이 가능한 환경이 된다.

    CDT는 개발하는 툴이지 컴파일러가 아니다. CDT를 설치했더라도 각각 운영체제 기반에서 제공하는 C/C++ 컴파일러와 연결하는 작업은 필요하다. 여기서는 CDT를 Eclipse에 설치하는 방법만 소개한다.

    Eclipse 메뉴에서 Help > Install New Software... 를 선택한다.

    아래와 같은 화면이 나오면 Add 버튼을 누른다.


    http://www.eclipse.org/cdt/downloads.php 에 가면 최신버전(현재 CDT 6.0.x)을 다운로드 받을 수 있는 링크가 소개되어 있다. Eclipse가 Galileo버전이므로 http://download.eclipse.org/tools/cdt/releases/galileo 를 URL로 삼아 플러그인을 설치하면 되겠다.

    아래처럼 Add Site창에 Name과 Location을 입력한다. Name은 아무거나 입력하면 된다.


    참고로 위처럼 등록하면 Windews > Preferences > Install/Update > Avaliable Software Sites에 아래처럼 등록되어 있다.


    이제 Work with 란에 CDT를 입력해보면 금방 등록했던 CDT 정보를 선택할 수 있다. 그럼 아래처럼 나온다. CDT Main Features, CDT Optional Features 모두 Check하고 Next버튼을 누른다.


    아래처럼 설치할 목록들이 나온다. Next버튼을 누른다.



    아래와 같은 화면이 나오면 I accept the terms of the license agreements를 선택후 Finish 버튼을 누르면 설를 시작한다. 시작이 완료된 다음에는 Eclipse를 재구동한다.



    Eclipse가 구동된 다음 C/C++ Perspective를 열어보자. Windows>Open Perspective>Other 를 선택한다. 아래처럼 창이 뜨면 C/C++를 선택한다. 
     

    Perspective창에 아래처럼 추가 된것을 확인하자. 이제 Eclipse에서

    File > New를 가도 C, C++ 프로젝트를 만들 수 있게 되었다.


    4. 간단한 C/C++ 개발해보기

    MinGW의 bin 폴더에 보면 gcc, g++등 각종 컴파일 도구가 있다. 이클립스의 CDT환경에서 C/C++로 개발할때는 MinGW의 컴파일 도구를 이용해 컴파일 한다는 사실을 기억하자.

    다음과 같이 C++ 프로젝트를 만들어보자.
    • 이클립스 메뉴에서 File > New > C++ Project를 선택한다.
    • 다음 그림과 같이 프로젝트를 만들기 위한 창이 나오면 Project name을 넣고 Project type을 Executable > Hello World C++ Project를 선택한다음 Toolchains를 MinGW GCC로 선택하도록 한다. 이렇게 하면 자동으로 Hello World CPP가 만들어지면서 컴파일은 MinGW의 g++컴파일러를 이용해 컴파일 할 수 있도록 설정 되는 것이다. Next 버튼을 누른다.
    • 간단한 셋팅을 하는데 이 설정에서 중요한 것은 Source 파일은 src 폴더에 들어가게 된다는 것이다. Next 버튼을 누른다.


    • 다음 그림과 같이 Debug, Release 두 버전으로 프로그램 결과를 별 수 있도록 셋팅된다. Finish 버튼을 누른다.

     

    이클립스의 Project > Build Automatically가 선택되어 있다면 위처럼 프로젝트를 만들게 되면 자동으로 MinGW의 g++을 찾아 컴파일을 실시하게 된다. 아래와 같은 메시지가 이클립스의 Console창에 나오면 제대로 실행된 것이다.


    위 메시지 처럼 컴파일을 하지 못하고  아래처럼 Nothing to build for Test1 메시지가 뜬다면 이것은 수정된 내용이 없으므로 컴파일할 필요가 없다는 것을 의미한다. 대신 Ctrl+B 하면 강제로 컴파일한다.


    이 프로젝트는 C++ 프로젝트이므로 gcc 컴파일러가 연결되어야 한다. 만약 컴파일에 실패한다면 Mingw/bin에 gcc.exe를 확인해보자. 만약에 없다면 위에 Mingw 설치하기를 다시 한번 따라해보길 바란다.

    실행해보자. 아래처럼 만들어진 프로젝트의 src폴더를 열어 Test1.cpp를 선택한다. 그리고 빨간 박스로 표시된 아이콘을 클릭하거나 Ctrl+F11을 하면 실행할 수 있다.

    Console창에 아래처럼 Hello World가 출력된것을 확인하자.

    Build Automatically를 체크한 경우에는 코드를 수정하고 저장할 때마다 자동 Build처리된다. 하지만 수동으로도 할 수 있는데 Ctrl+B 또는 아래 그림처럼 망치툴을 클릭해서 Build할 수 있다.



    개발시에는 Debug버전과 Release 버전이 있다는 것을 기억하자. 아래 보이는 도구는 현재 개발 환경이 Debug인지 Release인지 결정해 주는 도구이다. Debug는 개발용이고 Release는 외부로 배포할때 사용한다.


    실제로 이 도구를 이용해 Debug에서 Release로 바꿔보자. 아래처럼 Release 폴더가 생겨나고 컴파일 결과가 이 폴더안에 만들어진다. 이때부터는 실행할때 Release폴더에 있는 exe파일이 실행되게 된다.


    참고로 makefile을 기반으로한 개발을 하고 싶은 경우가 있을 수 있다. 이런 경우에는 C++ 프로젝트를 생성시에 아래 그림처럼 Makefile Project를 선택해서 생성해야한다.

    하지만 실제로 이 상태로 프로젝트를 생성해 컴파일하면 Cannot run program "make": Launching failed 메시지가 console창에 보이면서 컴파일이 불가능하다. 이 메시지는 컴파일을 수행할 수 있는 make 명령어를 찾지 못한다는 것을 의미한다. Eclipse에서는 기본적으로 make가 지정되어 있지만 MinGW의 make 명령은 mingw32-make로 다르다. 그러므로 이 문제를 해결하기 위해 mingw32-make.exe를 복사해 같은 폴더에 make.exe로 이름을 바꿔주면 된다. (물론 찾아보면 다른 방법도 있지만 이 방법이 가장 빠르고 쉽다.)

    makefile을 이용해 개발해보는 간단한 예제는 다음글을 참고한다.
    http://kkamagui.springnote.com/pages/446531


    5. 간단한 win32용 프로그램 개발하기
    지금까지의 예제는 단순히 Console창에 결과가 나온다. MinGW는 Windows API를 이용한 개발도 지원하므로 앞서 설명한 같은 C++ 프로젝트로 만들고 아래 코드로 변경해도 컴파일이 가능하다.


    #include <windows.h>
    
    int WinMain(HINSTANCE hInstance,
                         HINSTANCE hPrevInstance,
                         LPTSTR    lpCmdLine,
                         int       nCmdShow)
    {
            MessageBox(NULL, "Hello in EclipseCDT", "EclipseCDT", MB_OK);
            return 0;
    }
    


    실행해 보면 아래와 같은 다이얼로그 창이 나온다.

    경험자들에 따르면 Win32 로 개발하는 경우에는 한가지 중요한 C++ 링커 설정을 해야한다고 한다.

    먼저 해당 Win32 프로젝트를 선택후(필자의 경우 Test3) 이클립스 메뉴에서 Project > Properies로 들어갑니다. 아래처럼 창이 뜨면 C/C++ Build > Setting으로 들어가 Tool Setting 탭을 선택합니다. 거기에 MinGW C++ Linker>Miscellaneous를 선택해 Linker flags에 -mwindows를 입력한다. 완료하면 Apply버튼이나 OK 버튼을 누르면 적용된다.

    이 설정을 해야 군데 군데 "undefined reference"와 같은 에러를 발생시키지 않는다고 한다. 수정했는데도 에러를 띄우면 File->Save all 또는 이클립스 종료후 다시 시작하면 된다.

    Windows API 학습을 위해 다음 링크를 참고한다.
    http://www.winapi.co.kr/

    6. 디버깅 환경 만들기
    지금까지 개발환경으로 개발자체는 문제 없지만 디버깅은 할 수 없다. MinGW에 디버깅을 하기 위한 도구가 설치되어야 하는데 이를 가능하게 하는 것이 gdb이다.

    먼저 gdb를 다운로드 받자.
    http://downloads.sourceforge.net/project/mingw/GNU%20Source-Level%20Debugger/GDB-7.1/gdb-7.1-2-mingw32-bin.tar.gz

    압축을 풀고 bin과 share 폴더를 그대로 설치된 MinGW 폴더에 복사해준다. 이것으로 MinGW의 C/C++ 디버깅 환경이 구축되었다.

    이제 Eclipse에서 F11 누르거나 아래처럼 벌레모양의 아이콘을 눌러 Debugging을 할 수 있게 된다.


    디버깅을 하게 되면 Debug Perspective창으로 바뀌면서 아래처럼 디버깅이 가능해진다.

    참고로, 이클립스에서 디버깅 설정은 Run > Debug Configurations에서 할 수 있다. 좌측 리스트에서 C/C++ Application을 선택해 해당 exe를 선택한뒤 우측에서 Debugger 탭을 선택하면 Debugger를 선택할 수 있게 된다.

    만약 gdb를 설치했음에도 불구하고 에러를 내면서 디버깅을 할 수 없는 경우 CMD창에서 다음과 같이 입력해보길 바란다.



    만약 위처럼 메시지가 나오지 않고 libexpat-1.dll이 없다고 경고창이 나오면 현재 설치한 gdb버전이 libexpat-1.dll과 의존성이 있는 것이다. 이때는 libexpat-1.dll도 함께 다운로드 받아 MingGW/bin에 복사해줘야 한다.

    libexpat-1.dll은 아래 링크에서 다운로드 받는다.
    http://downloads.sourceforge.net/project/mingw/MinGW%20expat/expat-2.0.1-1/libexpat-2.0.1-1-mingw32-dll-1.tar.gz

    다음 글을 참고한다.
    http://forums.codeblocks.org/index.php/topic,11301.msg77273.html

    7. 정리하며
    프로젝트 중에 C와 MySQL을 연동하여 개발할 경우가 있어서 전체 환경설정을 정리한다는 마음으로 글을 적었다. 기존에 나와 있는 많은 글들이 너무 옛날 버전이라서 그런지 지금과 맞지 않는 부분도 있었다. 앞으로 MySQL과 연동하게 되면 관련 내용도 소개해 볼까 한다. 개발에 있어서 환경을 구축하고 적응하는게 반인 것 같다. ^^;


    8. 참고글

    이클립스(Eclipse) CDT 설치
    (Eclipse Galileo) C/C++ Developments User Guide
    CDT를 이용한 Windows C/C++ 개발 환경 만들기
    Eclipse/CDT
    Eclipse Project CDT (C/C++) Plugin Tutorial 1, 2By Brian Lee
    이클립스(eclipse)를 이용해서 C/C++ 프로그래밍 환경설정
    MinGW + Eclipse 를 이용한 Windows 개발 환경 구현

    글쓴이 : 지돌스타(http://blog.jidolstar.com/677)

    빵집 개발자 양병규님께서 이 글의 이전 글인 Adobe Alchemy 속도 테스트에 대해 이런 답변을 달아주셨다.


    컴파일러에 대해서 조금 관심을 가져보시면 알 수 있을텐데요…
    음… 뭐랄까…
    그 최적화라는 것이 불필요한 일은 안하고 같은 기능이라면 더 빠른 기능으로 대치하고.. 그런일을 하는 것이 컴파일러의 최적화인데요..
    제가 보기에는
    for( i=0; i < 1000000; i++ )
    {
    result = sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3);
    }
    이 부분이.. 최적화를 하면 루프를 1000000번 돌지 않고 한방에 끝낼것같습니다. 최적화알고리즘중에서 루프문안에서의 내용이 반복을 해도 변화가 없는 경우에는 루프를 한방에 끝내도록 하는 알고리즘이 있습니다. 이 예가 그런 예일것 같은데요..

    암튼.. ActionScript에는 그런 최적화가 없는데 이미 오랜 역사동안 만들어진 C/C++언어의 최적화 기술이 적용되면 분명히 나은 결과를 보일 것 으로 예상됩니다. ^^;(물론 코딩하는 사람의 실력이 좋을 수록 최적화의 효과가 떨어지겠지만)

    그리고..
    저는 아무리 봐도 C/C++로 코딩한 것이 결국 몽땅 ActionScript로 만들어지는 것이 맞는 것 같습니다. SWF에는 ActionScript 이 외에 다른 실행코드는 존재하지 않습니다. 최종적으로 만들어진 결과가 *.SWF(*.SWC)이지 않습니까? SWF File Format Specification Version 10 문서 278페이지를 다 훑어봐도 ActionScript 이외에는 실행코드가 없습니다. 머.. DLL을 임포트한다거나 별도의 실행코드용 외부 라이브러리가 있다거나… 그런건 전혀 없습니다.

    malloc 함수 같은 경우의 예를 들어보면 ActionScript에는 malloc과 동일한 역할을 하는 어셈블명령은 없습니다. 하지만 ActionInitArray와 같이 긴 변수를 사용할 수 있는 명령으로 ‘구현’은 할 수 있을겁니다. 아마도 그런 방법으로 구현되지 않았나싶습니다.

    어쨋든 Alchemy는 C/C++을 100% ActionScript로 변환해 주는게 맞고.. 함수사용, 변수사용, 최적화, 수학함수의 구현, 각종 기초 알고리즘등 기초적인 부분에서 훨씬 우월하기 때문에 좋은 효과를 나타내고 있는 것으로 생각됩니다.

    시간이 나면 Alchemy에서 만들어진 SWF 파일을 분석해 보면 아주 좋은 공부가 될것같습니다. ^^;

    양병규님의 의견중 최적화에 대한 것을 다시 살펴보자면 -O3 옵션으로 인해 최적화 알고리즘이 적용되어 for문이 없어지고 result = sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3); 만 남는다는 것을 지적하고 ActionScript 3.0에는 이런 최적화 기능이 없기 때문에 실제로 돌려보면 C코드는 1번만 수행하는 반면 ActionScript 3.0에서는 원래대로 1백만번 루프를 돈다는 것이다.

     

    또한 여러 상황에 비추어볼때 Alchemy는 C/C++ 코드를 100% ActionScript 3.0으로 변경하는게 맞다고 말씀해 주었다.

     

    이 의견을 읽고 맞는 말인 것 같다고 생각해서 코드를 다음과 같이 수정했다.

     

    1. C 코드 최적화를 방지해서 다시 속도 테스트

    speedtest.c

    #include <math.h>
    #include <stdlib.h>
    #include "AS3.h"

    static AS3_Val c_speed_test(void* self, AS3_Val args)
    {
        int i;
        double result = 0;
        for( i=0; i < 10000000; i++ )
        {
            result += sin( i ) * cos( i );
        }
        return AS3_Number(result);
    }

    int main()
    {
        AS3_Val method = AS3_Function( NULL, c_speed_test );
        AS3_Val result = AS3_Object( "c_speed_test: AS3ValType", method );
        AS3_Release( method );
        AS3_LibInit( result );
        return 0;
    }

     

    AlchemySpeedTest.as

    package {
        import cmodule.speedtest.CLibInit;

        import flash.display.Sprite;
        import flash.display.StageAlign;
        import flash.display.StageScaleMode;
        import flash.text.TextField;
        import flash.text.TextFieldAutoSize;
        import flash.text.TextFormat;
        import flash.utils.getTimer;

        public class AlchemySpeedTest extends Sprite
        {
            public function AlchemySpeedTest()
            {
                stage.scaleMode = StageScaleMode.NO_SCALE;
                stage.align = StageAlign.TOP_LEFT;

                var loader:CLibInit = new CLibInit();
                var lib:Object = loader.init();
                var startTime:Number;

                startTime = getTimer();
                var cResult:String = "c returned value : " + lib.c_speed_test(null) + " delay time(ms) : " + (getTimer()-startTime);

                startTime = getTimer();
                var asResult:String = "as3 returned value : " + as3_speed_test() + " delay time(ms) : " + (getTimer()-startTime);

                var textField:TextField = new TextField();
                textField.text = cResult + "\n" + asResult;
                textField.width = 500;
                textField.autoSize = TextFieldAutoSize.LEFT;
                textField.wordWrap = true;
                textField.defaultTextFormat = new TextFormat( null, 12 );
                addChild(textField);

            }
            public function as3_speed_test():Number
            {
                var i:int;
                var result:Number = 0;
                for (i = 0; i < 10000000; i++)
                {
                    result += Math.sin( i ) + Math.cos( i );
                }
                return result;
            }
        }
    }

     

    이 코드에서 달라진 것은 gcc로 c를 컴파일 할 때 -O3와 같은 최적화 알고리즘 적용을 하더라도 전과 같이 for문이 삭제되는 것을 방지하도록 했다.

     

    이전 코드

    for( i=0; i < 1000000; i++ )
    {
            result = sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3);
    }

     

    새로 바꾼 코드

    for( i=0; i < 10000000; i++ )
    {
            result += sin( i ) * cos( i );
    }

    새로 바꾼 코드는 sin(), cos()함수에 계속 변화되는 값을 넣어주었고 그 결과가 누적되도록 했다. 이로써 최적화를 하더라도 for문이 적용되지 않는 경우는 없을 것이다.

    컴파일은 아래와 같이 한다.

    gcc speedtest.c –03 –Wall –swc –o speedtest.swc
    mxmlc.exe –library-path+=speedtest.swc –target-player=10.0.0 AlchemySpeedTest.as

    결과는 다음과 같다.

    c returned value : 0.24755567269650028 delay time(ms) : 3425
    as3 returned value : 2.873882594355213 delay time(ms) : 3184

    예상대로 gcc –O3 로 인해 최적화가 적용되었던 것이다. 양병규 님의 말에 힘이 실리는 듯하다.

     

    2. ActionScript 3.0 Native Vector3D, Matrix3D와 C++의 Vector3D, Matrix3D 속도테스트

     

    Flash Player 10부터 추가된 ActionScript 3.0 API중에 Vector3D, Matrix3D가 있다. 이 클래스들은 3D 표현을 위한 다양한 기능을 제공하고 있다. Native 코드이므로 소스코드는 직접 볼 수 없다.

     

    ActionScript 3.0의 Vector3D와 Matrix3D 대신 C++로 Vector3D, Matrix3D를 만들어서 서로 수행속도를 비교해보도록 하겠다.

     

    아래는 Vector3D와 Matrix3D C++코드, 그리고 이들을 속도 테스트 할 수 있는 C++코드, ActionScript 3.0과 C++과 속도 테스트 할 수 있도록 제작한 ActionScript 3.0 코드가 나열되어 있다.

     

    Vector3D.h

    #ifndef VECTOR3D_H_
    #define VECTOR3D_H_

    #include "AS3.h"

    class Vector3D {

    public :
      Vector3D();
      Vector3D(double x, double y, double z);
      Vector3D(const AS3_Val& as3Vector);
      virtual ~Vector3D();

      double dot(const Vector3D& v) const;
      Vector3D cross(const Vector3D& v) const;
      double modulus() const;
      Vector3D normalise() const;

      void setX(double x);
      void setY(double y);
      void setZ(double z);
      double getX() const;
      double getY() const;
      double getZ() const;

    private :
      double _x;
      double _y;
      double _z;

    };

    #endif /*VECTOR3D_H_*/

     

    Matrix3D.h

    #ifndef MATRIX3D_H_
    #define MATRIX3D_H_

    #include "Vector3D.h"

    class Matrix3D {

    public :
      Matrix3D();
      virtual ~Matrix3D();

      void setRotationX(double degrees);
      void setRotationY(double degrees);
      void setRotationZ(double degrees);

      void setIdentity();

      Vector3D transformVector(const Vector3D& vector) const;

    private :
      double _M00;
      double _M01;
      double _M02;
      double _M10;
      double _M11;
      double _M12;
      double _M20;
      double _M21;
      double _M22;

    };

    #endif /*MATRIX3D_H_*/

     

    Vector3D.cpp

    #include "Vector3D.h"
    #include <cmath>

    Vector3D::Vector3D() :
      _x(0),
      _y(0),
      _z(0) {
    }

    Vector3D::Vector3D(const AS3_Val& as3Vector) {
      AS3_ObjectValue(as3Vector, "x:DoubleType, y:DoubleType, z:DoubleType", &_x, &_y, &_z);
    }

    Vector3D::Vector3D(double x, double y, double z) :
      _x(x),
      _y(y),
      _z(z) {
    }

    Vector3D::~Vector3D() {
    }

    double Vector3D::dot(const Vector3D& v) const {
      return v._x*_x + v._y*_y + v._z*_z;
    }

    Vector3D Vector3D::cross(const Vector3D& v) const {

      Vector3D result;
      result._x = _y*v._z - _z*v._y;
      result._y = _z*v._x - _x*v._z;
      result._z = _x*v._y - _y*v._x;
      return result;
    }

    double Vector3D::modulus() const {
      return std::sqrt(_x*_x + _y*_y + _z*_z);
    }

    Vector3D Vector3D::normalise() const {
      double mod = modulus();
      return Vector3D(_x/mod, _y/mod, _z/mod);
    }

    void Vector3D::setX(double x) {
      _x = x;
    }

    void Vector3D::setY(double y) {
      _y = y;
    }

    void Vector3D::setZ(double z) {
      _z = z;
    }

    double Vector3D::getX() const {
      return _x;
    }

    double Vector3D::getY() const {
      return _y;
    }

    double Vector3D::getZ() const {
      return _z;
    }

    Matrix3D.cpp

    #include "Matrix3D.h"
    #include <cmath>

    Matrix3D::Matrix3D() :
      _M00(1),
      _M01(0),
      _M02(0),
      _M10(0),
      _M11(1),
      _M12(0),
      _M20(0),
      _M21(0),
      _M22(1) {
    }

    Matrix3D::~Matrix3D() {
    }

    void Matrix3D::setIdentity() {
      _M00 = 1;
      _M01 = 0;
      _M02 = 0;
      _M10 = 0;
      _M11 = 1;
      _M12 = 0;
      _M20 = 0;
      _M21 = 0;
      _M22 = 1;
    }

    void Matrix3D::setRotationX(double degrees) {
      setIdentity();
      double radians = degrees / 180 * M_PI;
      _M11 = cos(radians);
      _M12 = -sin(radians);
      _M21 = sin(radians);
      _M22 = cos(radians);
    }

    void Matrix3D::setRotationY(double degrees) {
      setIdentity();
      double radians = degrees / 180 * M_PI;
      _M00 = cos(radians);
      _M02 = sin(radians);
      _M20 = -sin(radians);
      _M22 = cos(radians);
    }

    void Matrix3D::setRotationZ(double degrees) {
      setIdentity();
      double radians = degrees / 180 * M_PI;
      _M00 = cos(radians);
      _M01 = -sin(radians);
      _M10 = sin(radians);
      _M11 = cos(radians);
    }

    Vector3D Matrix3D::transformVector(const Vector3D& vector) const {
      Vector3D result;
      result.setX(_M00*vector.getX() + _M01*vector.getY() + _M02*vector.getZ());
      result.setY(_M10*vector.getX() + _M11*vector.getY() + _M12*vector.getZ());
      result.setZ(_M20*vector.getX() + _M21*vector.getY() + _M22*vector.getZ());
      return result;
    }

    alchemy_speed_test.cpp

    #include "AS3.h"
    #include "Vector3D.h"
    #include "Matrix3D.h"

    AS3_Val speedTest1(void* self, AS3_Val args) {

      // Declare AS3 variables
      AS3_Val as3Vector1;
      AS3_Val as3Vector2;
      // Extract variables from arguments array
      AS3_ArrayValue(args, "AS3ValType, AS3ValType", &as3Vector1, &as3Vector2);
      // Create native C++ objects with AS3 parameters
      Vector3D vector1(as3Vector1);
      Vector3D vector2(as3Vector2);
      Vector3D vector3;
      // Speed test : calculate cross products and normalise
      for (int i = 0; i < 1000000; i++) {
        vector3 = vector1.cross(vector2);
        vector3 = vector3.normalise();
        vector1 = vector2;
        vector2 = vector3;
      }

      // Obtain a class descriptor for the AS3 Vector3D class
      AS3_Val vector3DClass = AS3_NSGet(AS3_String("flash.geom"), AS3_String("Vector3D"));
      AS3_Val params = AS3_Array("");
      // Construct a new AS3 Vector3D object with empty parameters
      AS3_Val result = AS3_New(vector3DClass, params);
      // Set the x, y and z properties of the AS3 Vector3D object, casting as appropriate
      AS3_Set(result, AS3_String("x"), AS3_Number(vector3.getX()));
      AS3_Set(result, AS3_String("y"), AS3_Number(vector3.getY()));
      AS3_Set(result, AS3_String("z"), AS3_Number(vector3.getZ()));

      // Release what’s no longer needed
      AS3_Release(params);
      AS3_Release(vector3DClass);
      // return the AS3 Vector
      return result;
    }

    AS3_Val speedTest2(void* self, AS3_Val args) {

      // Declare AS3 variable
      AS3_Val as3Vector;
      // Extract variables from arguments array
      AS3_ArrayValue(args, "AS3ValType", &as3Vector);

      // Create native C++ object with AS3 parameters
      Vector3D vector(as3Vector);
      Vector3D copy = vector;
      Matrix3D rotationX;
      Matrix3D rotationY;
      Matrix3D rotationZ;
      // Speed test : calculate rotation matrices and transform vector
      for (int i = 0; i < 1000; i++) {
        vector = copy;
        for (double ang = 0; ang < 180; ang++) {
          rotationX.setRotationX(ang);
          rotationY.setRotationY(ang);
          rotationZ.setRotationZ(ang);
          vector = rotationX.transformVector(vector);
          vector = rotationY.transformVector(vector);
          vector = rotationZ.transformVector(vector);
        }
      }

      // Obtain a class descriptor for the AS3 Vector3D class
      AS3_Val vector3DClass = AS3_NSGet(AS3_String("flash.geom"), AS3_String("Vector3D"));
      AS3_Val params = AS3_Array("");
      // Construct a new AS3 Vector3D object with empty parameters
      AS3_Val result = AS3_New(vector3DClass, params);
      // Set the x, y and z properties of the AS3 Vector3D object, casting as appropriate
      AS3_Set(result, AS3_String("x"), AS3_Number(vector.getX()));
      AS3_Set(result, AS3_String("y"), AS3_Number(vector.getY()));
      AS3_Set(result, AS3_String("z"), AS3_Number(vector.getZ()));

      // Release what’s no longer needed
      AS3_Release(params);
      AS3_Release(vector3DClass);
      // return the AS3 Vector
      return result;
    }

    /**
    * Main entry point for Alchemy compiler. Declares all functions available
    * through the Alchemy bridge.
    */
    int main() {
      // Declare all methods exposed to AS3 typed as Function instances
      AS3_Val speedTest1Method = AS3_Function(NULL, speedTest1);
      AS3_Val speedTest2Method = AS3_Function(NULL, speedTest2);

      // Construct an object that contains references to all the functions
      AS3_Val result = AS3_Object("speedTest1:AS3ValType, speedTest2:AS3ValType", speedTest1Method, speedTest2Method);

      // Release what’s no longer needed
      AS3_Release(speedTest1Method);
      AS3_Release(speedTest2Method);

      // Notify the bridge of what has been created — THIS DOES NOT RETURN!
      AS3_LibInit(result);

      // Should never get here!
      return 0;
    }

    AlchemySpeedTest.as

    package {

      import cmodule.alchemy_speed_test.CLibInit;
      import flash.display.Sprite;
      import flash.display.StageAlign;
      import flash.display.StageScaleMode;
      import flash.geom.Matrix3D;
      import flash.geom.Vector3D;
      import flash.text.TextField;
      import flash.text.TextFieldAutoSize;
      import flash.utils.getTimer;

      public class AlchemySpeedTest extends Sprite {

        private var vectorUtils:Object;

        public function AlchemySpeedTest() {

          // Set up the stage
          stage.align = StageAlign.TOP_LEFT;
          stage.scaleMode = StageScaleMode.NO_SCALE;

          // Create the Alchemy bridge to C++ methods
          var loader:CLibInit = new CLibInit;
          vectorUtils = loader.init();

          // Create a text field          
          var timerText1:TextField = new TextField();
          var timerText2:TextField = new TextField();
          var timerText3:TextField = new TextField();
          var timerText4:TextField = new TextField();
          timerText1.autoSize = TextFieldAutoSize.LEFT;
          timerText2.autoSize = TextFieldAutoSize.LEFT;
          timerText3.autoSize = TextFieldAutoSize.LEFT;
          timerText4.autoSize = TextFieldAutoSize.LEFT;
          timerText1.y = 0;
          timerText2.y = 30;
          timerText3.y = 60;
          timerText4.y = 90;
          addChild(timerText1);
          addChild(timerText2);
          addChild(timerText3);
          addChild(timerText4);
          var time0:int;
          var totalTime1:int;
          var totalTime2:int;
          var totalTime3:int;
          var totalTime4:int;

          // Perform the speed test
          time0 = getTimer();
          var vector1:Vector3D = speedTest1();
          totalTime1 = getTimer() - time0;

          time0 = getTimer();
          var vector2:Vector3D = speedTest2();
          totalTime2 = getTimer() - time0;

          time0 = getTimer();
          var vector3:Vector3D = nativeSpeedTest1();
          totalTime3 = getTimer() - time0;

          time0 = getTimer();
          var vector4:Vector3D = nativeSpeedTest2();
          totalTime4 = getTimer() - time0;
          // Display elapsed time and final vector
          timerText1.text = "1. Alchemy Time taken = " + totalTime1 + " vector = (" + vector1.x + ", " + vector1.y + ", " + vector1.z + ")";
          timerText2.text = "1. Native  Time taken = " + totalTime3 + " vector = (" + vector3.x + ", " + vector3.y + ", " + vector3.z + ")";
          timerText3.text = "2. Alchemy Time taken = " + totalTime2 + " vector = (" + vector2.x + ", " + vector2.y + ", " + vector2.z + ")";
          timerText4.text = "2. Native  Time taken = " + totalTime4 + " vector = (" + vector4.x + ", " + vector4.y + ", " + vector4.z + ")";
        }

        /**
         * Speed test using C++ to iteratively calculate the cross products of two vectors
         */
        private function speedTest1():Vector3D {
          var vector1:Vector3D = new Vector3D(0.123, 0.456, 0.789);
          var vector2:Vector3D = new Vector3D(0.987, 0.654, 0.321);

          return vectorUtils.speedTest1(vector1, vector2);
        }

        /**
         * Speed test using C++ to iteratively calculate rotation matrices and apply these to a vector
         */
        private function speedTest2():Vector3D {
          var vector:Vector3D = new Vector3D(0.123, 0.456, 0.789);
          return vectorUtils.speedTest2(vector);    
        }

        /**
         * Speed test using AS3 to iteratively calculate the cross products of two vectors
         */
        private function nativeSpeedTest1():Vector3D {
          var vector1:Vector3D = new Vector3D(0.123, 0.456, 0.789);
          var vector2:Vector3D = new Vector3D(0.987, 0.654, 0.321);
          var vector3:Vector3D;
          var time0:int = getTimer()
          for (var i:int = 0; i < 1000000; i++) {
            vector3 = vector1.crossProduct(vector2);
            vector3.normalize();
            vector1 = vector2;
            vector2 = vector3;
          }
          return vector3;
        }

        /**
         * Speed test using AS3 to iteratively calculate rotation matrices and apply these to a vector
         */
        private function nativeSpeedTest2():Vector3D {
          var vector:Vector3D = new Vector3D(0.123, 0.456, 0.789);

          var copy:Vector3D = vector.clone();

          var rotationX:Matrix3D = new Matrix3D();
          var rotationY:Matrix3D = new Matrix3D();
          var rotationZ:Matrix3D = new Matrix3D();

          for (var i:int = 0; i < 1000; i++) {
            vector = copy.clone();
            for (var ang:Number = 0; ang < 180; ang++) {
              rotationX.identity();
              rotationX.appendRotation(ang, Vector3D.X_AXIS);
              rotationY.identity();
              rotationY.appendRotation(ang, Vector3D.Y_AXIS);
              rotationZ.identity();
              rotationZ.appendRotation(ang, Vector3D.Z_AXIS);
              vector = rotationX.transformVector(vector);
              vector = rotationY.transformVector(vector);
              vector = rotationZ.transformVector(vector);
            }
          }
          return vector;
        }

      }
    }

    위 코드에서 alchemy_speed_test.cpp에 speedTest1(), speedTest2()가 만들어져 있고 AlchemySpeedTest.as 안에는 C++ 코드를 호출할 수 있는 함수와 ActionScript 3.0 Native Vector3D와 Matrix3D 속도를 테스트해보는 nativeSpeedTest1(), nativeSpeedTest2() 함수가 정의되어 있다.

     

    speedTest1()과 nativeSpeedTest1()은 2개의 Vector간에 dot product 연산과 Normalisation을 1백만번 반복해서 결과를 반환하다. 반면 speedTest2()와 nativeSpeedTest2()는 x,y,z축 회전에 대한 Matrix를 3개 만들어 Vector를 회전을 반복한 다음 결과를 반환한다.

     

    C++파일들을 컴파일 하기 위해 Makefile을 만들었다.

    .SUFFIXES: .cpp .c .o

    NAME=alchemy_speed_test
    PATH:=${ALCHEMY_HOME}/achacks:${PATH}
    CC = gcc
    CCPP = g++
    FLAGS = -O3 -Wall
    OBJS =  $(NAME).o Matrix3D.o Vector3D.o

    .cpp.o:
        $(CCPP) $(FLAGS) -c $<
    .c.o:
        $(CC) $(FLAGS) -c $<

    $(NAME) : $(OBJS)
        $(CC) $(FLAGS) -swc -o $(NAME).swc $(OBJS)

    clean:
        rm $(OBJS) $(NAME).swc
        rm swfbridge.log
        rm *achacks*
        rm -r _sb_*

    Window사용자중 Cygwin을 사용하시는 분은 make 패키지를 설치해야 이 Makefile을 구동할 수 있다.

     

    프롬프트 상에서 make 명령을 하면 Makefile을 구동하여 C++파일을 컴파일 할 수 있다.  

     


     

    만약 make를 사용하지 않으면 아래와 같이 컴파일해도 된다.

    g++ –O3 –Wall –c alchemy_speed_test.cpp
    g++ –O3 –Wall –c Matrix3D.cpp
    g++ –O3 –Wall –c Vector3D.cpp
    gcc –O3 –Wall –swc –o alchemy_speed_test.swc alchemy_speed_test.o Matrix3D.o Vector3D.o

     

    마지막으로 컴파일된 alchemy_speed_test.swc 을 AlchemySpeedTest.as에 추가해서 컴파일 한다.

    mxmlc.exe –library-path+=alchemy_speed_test.swc –target-player=10.0.0 AlchemySpeedTest.as

     

    생성된 AlchemySpeedTest.swf 를 Flash Player 10에서 구동하면 다음과 같은 결과가 나온다.

    1. Alchemy Time taken = 200 vector = (-0.40824829046386324, 0.8164965809277259, -0.4082482904638632)

    1. Native  Time taken = 1065 vector = (-0.4082482904638631, 0.816496580927726, -0.4082482904638629)

    2. Alchemy Time taken = 290 vector = (-0.6365049502756422, 0.662044570582514, -0.04630804289556738)

    2. Native  Time taken = 893 vector = (-0.6365604400634766, 0.6619919538497925, -0.04631434381008148)

     

    결국 결과는 다음과 같다.

    Vector dot Product 연산과 Normalisation의 경우
    - Alchemy : 201 ms
    - Native : 1090 ms

    회전행렬 생성과 Vector 변환의 경우
    - Alchemy : 301 ms
    - Native : 908 ms

    이전과 다르게 수행속도의 차이를 보이고 있다. 이 결과만 놓고 볼 때 필요할 때는 C/C++로 만들어 최적화 할 수 있도록 만들 수 있겠다는 생각을 가진다. 하지만 많은 차이를 보이지 않아 실제 속도해결에 있어서 필요성에 대해서는 의문을 가질 수 있겠다. 아래서부터 Alchemy를 더욱 이해해 보도록 하겠다.

     

    Alchemy를 깊게 이해하자.

     

    Adobe labs에서 Alchemy에 대한 소개를 보면 ActionScript 3.0 코드보다 더욱 빠를 것이다라고 언급하고 있다. 하지만 지금까지의 결과를 볼 때 실제로는 기대만큼 효과적으로 빠른 것 같지는 않다. Alchemy를 사용해서 수행속도에 대한 이점을 이끌어내기 위해서는 Alchemy 본질을 어느 정도 이해할 필요가 있다고 생각했다.

     

    아래 Alchemy에 대한 내용은 나름대로 자료를 찾아서 안되는 영어로 번역해보고 분석해봐서 정리한 내용이다. 혹시 잘못된 내용이 있을 수 있다. 따끔한 지적도 마다하지 않겠다. ^^

     

    Alchemy를 이용해 C/C++ 코드를 SWF로 컴파일 하는 과정은 다음과 같다.

    1. C/C++ 코드를 LLVM(Low Level Virtual Machine) 바이트 코드로 변환한다.(확장자 .bc)
    2. LLVM 코드를 ActionScript 3.0 코드로 변환한다. (확장자 .as)
    3. ActionScript 3.0 코드를 ActionScript Byte Code로 변환한다.(확장자 .abc)
    4. 마지막으로 swc를 만든다. (확장자 .swc)

    Alchemy의 중요 요소중 하나는 LLVM(Low Level Virtual Machine)이다. LLVM은 컴파일러 컴포넌트로 여러 언어를 중간코드로 변경하여 언어와 플랫폼에 독립적이고 컴파일, 링크시 런타임등 각 시점에서 최적화를 시켜준다. 자체적인 중간코드(intermediate representation)을 바탕으로 프로그래밍 언어와 CPU에 독립적인 최적화기, GCC기반의 C/C++ 프론트엔드(front-end), 그리고 X86, X86-64, PowerPC, ARM, IA-64, SPARC, Mips, Alpha, c 소스 백엔드(back-end), 또한 메모리에 코드를 생성해 실행할 수 있는 JIT 백엔드 등을 포함하고 있다.

     

    Alchemy 설치 디렉토리를 $ALCHEMY_HOME 이라고 한다면 $ALCHEMY_HOME/achacks 내에 gcc가 있다. gcc는 sh코드로 만들어져 있고 이 안에서 C/C++코드를 SWC로 컴파일하기 위한 모든 과정이 들어간다. gcc 파일에서 첫번째 하는 과정은 해당 C/C++코드를 LLVM 바이트 코드(.bc)로 바꾸는 일이다. 이때 사용되는 도구가 $ALCHEMY_HOME/bin/llvm-gcc와 llvm-ld이다. 예를 들어 아래와 같은 코드가 실행된다.

    $ llvm-gcc -v -emit-llvm -nostdinc -I$ALCHEMY_HOME/avm2-libc/include -I/usr/local/include –include $ALCHEMY_HOME/avm2-libc/avm2/AVM2Env.h echotest.c -c -o echo.o

    $ llvm-ld -o=echotest -O5 -internalize-public-api-list=_start,malloc,free,__adddi3,__anddi3,__ashldi3,__ashrdi3,__cmpdi2,__divdi3, __fixdfdi,__fixsfdi,__fixunsdfdi,__fixunssfdi,__floatdidf,__floatdisf,__floatunsdidf, __iordi3,__lshldi3,__lshrdi3,__moddi3,__muldi3,__negdi2,__one_cmpldi2,__qdivrem, __adddi3,__anddi3,__ashldi3,__ashrdi3,__cmpdi2,__divdi3,__qdivrem,__fixdfdi, __fixsfdi,__fixunsdfdi,__fixunssfdi,__floatdidf,__floatdisf,__floatunsdidf,__iordi3, __lshldi3,__lshrdi3,__moddi3,__muldi3,__negdi2,__one_cmpldi2,__subdi3, __ucmpdi2,__udivdi3,__umoddi3,__xordi3,__subdi3,__ucmpdi2,__udivdi3, __umoddi3,__xordi3,__error $ALCHEMY_HOME/avm2-libc/lib/avm2-libc.l.bc echotest.o

    위 과정은 llvm-gcc로 echotest.c를 echotest.o로 만들고 llvm-ld로 echotest.o를 avm2-libc.l.bc와 링크해서 echotest와 echotest.bc를 만들어준다. echotest는 echotest.bc를 실행하는 sh파일이다.

     

    참고로 LLVM 바이트 코드인 echotest.bc는 $ALCHEMY_HOME/bin/llvm-dis를 이용해 이 도구는 disassemble하는 역할을 한다.  LLVM 홈페이지에 online demo를 보면 쉽게 이런 과정을 볼 수 있다. online demo에서 LLVM disassemble를 보면 다음 c코드가 어떻게 LLVM 바이트 코드로 바뀌는지 확인해볼 수 있다.

    #include <stdio.h>
    int main(int argc, char **argv) {
        printf("%d\n", 1);
    }

    다음은 위 코드를 LLVM 바이트 코드로 바꾼 것은 disassemble 한 것이다.

    ; ModuleID = ‘/tmp/webcompile/_5616_0.bc’
    target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
    target triple = "i386-pc-linux-gnu"
    @.str = internal constant [4 x i8] c"%d\0A\00"        ; <[4 x i8]*> [#uses=1]

    define i32 @main(i32 %argc, i8** %argv) nounwind {
    entry:
        %0 = tail call i32 (i8*, …)* @printf(i8* noalias getelementptr ([4 x i8]* @.str, i32 0, i32 0), i32 1) nounwind        ; <i32> [#uses=0]
        ret i32 undef
    }

    declare i32 @printf(i8*, …) nounwind

     

    다음으로 $ALCHEMY_HOME/bin에 있는 llc 도구를 이용해 ActionScript 3.0 코드를 만든다.

    $ llc -march=avm2 -avm2-use-memuser -o=echotest.as -avm2-package-name=cmodule.echotest echotest.bc

    다음 코드가 만들어진 ActionScript 3.0 코드이다.

    package cmodule.speedtest {
    // Start of file scope inline assembly
    import flash.utils.*
    import flash.display.*
    import flash.text.*
    import flash.events.*
    import flash.net.*
    import flash.system.*

    public var gdomainClass:Class;
    public var gshell:Boolean = false;

    public function establishEnv():void
    {
      try
      {
        var ns:Namespace = new Namespace("avmplus");
        gdomainClass = ns::["Domain"];
        gshell = true;
      }
      catch(e:*) {}
      if(!gdomainClass)
      {
        var ns:Namespace = new Namespace("flash.system");
        gdomainClass = ns::["ApplicationDomain"];
      }
    }

    establishEnv();

    ……(생략)

    public const _c_speed_test:int = regFunc(FSM_c_speed_test.start)

    public final class FSM_c_speed_test extends Machine {

        public static function start():void {
                var result:FSM_c_speed_test = new FSM_c_speed_test
            gstate.gworker = result
        }

        public var i0:int

        public static const intRegCount:int = 1
        public var f0:Number, f1:Number, f2:Number, f3:Number

        public static const NumberRegCount:int = 4
        public final override function work():void {
            Alchemy::SetjmpAbuse { freezeCache = 0; }
            __asm(label, lbl("_c_speed_test_entry"))
            __asm(push(state), switchjump(
                "_c_speed_test_errState",
                "_c_speed_test_state0",
                "_c_speed_test_state1"))
        __asm(lbl("_c_speed_test_state0"))
        __asm(lbl("_c_speed_test__XprivateX__BB75_0_F"))
            mstate.esp -= 4; __asm(push(mstate.ebp), push(mstate.esp), op(0×3c))
            mstate.ebp = mstate.esp
            mstate.esp -= 0
            f0 =  (0)
            i0 =  (0)
        __asm(jump, target("_c_speed_test__XprivateX__BB75_1_F"), lbl("_c_speed_test__XprivateX__BB75_1_B"), label, lbl("_c_speed_test__XprivateX__BB75_1_F"));
            f1 = f0
            f2 =  (Number(i0))
            f0 = f2
            //InlineAsmStart
        f0 =  Math.sin(f0);

        //InlineAsmEnd
            f3 = f0
            f0 = f2
            //InlineAsmStart
        f0 =  Math.cos(f0);

        //InlineAsmEnd
            f0 =  (f3 * f0)
            i0 =  (i0 + 1)
            f0 =  (f0 + f1)
            __asm(push(i0==10000000), iftrue, target("_c_speed_test__XprivateX__BB75_3_F"))
        __asm(lbl("_c_speed_test__XprivateX__BB75_2_F"))
            __asm(jump, target("_c_speed_test__XprivateX__BB75_1_B"))
        __asm(lbl("_c_speed_test__XprivateX__BB75_3_F"))
            mstate.esp -= 8
            __asm(push(f0), push(mstate.esp), op(0×3e))
            state = 1
            mstate.esp -= 4;(mstate.funcs[_AS3_Number])()
            return
        __asm(lbl("_c_speed_test_state1"))
            i0 = mstate.eax
            mstate.esp += 8
            mstate.eax = i0
            mstate.esp = mstate.ebp
            mstate.ebp = __xasm<int>(push(mstate.esp), op(0×37)); mstate.esp += 4
            //RETL
            mstate.esp += 4
            mstate.gworker = caller
            return
        __asm(lbl("_c_speed_test_errState"))
            throw("Invalid state in _c_speed_test")
        }
    }

    ……(생략)

     

     

    Alchemy로 C 또는 C++ 코드의 컴파일 결과는 기본적으로 ActionScript 와 AVM2 바이트 코드로 만들어진 하나의 클래스가 된다. 이 과정에서 결과물인 SWC는 C와 C++이 C 라이브러리와 POSIX를 지원에 필요할 수 있는 것도 함께 컴파일 되므로 크기가 커진다. 가령 54줄의 C코드를 Alchemy를 통해 컴파일 하면 27415줄의 ActionScript 코드가 만들어진다. 방금 위에서 이러한 현상을 확인할 수 있었다.

     

    다음으로 asc.jar를 이용해 만들어진 ActionScript 파일을 swf로 만든다. 이 과정에서 playerglobal.abc와 global.abc를 포함한다.

    $ java -Xms16M -Xmx1024M -jar $ALCHEMY_HOME/bin/asc.jar -AS3 -strict -import $ALCHEMY_HOME/flashlibs/global.abc -import $ALCHEMY_HOME/playerglobal.abc -d -config Alchemy::Shell=false -config Alchemy::NoShell=true -config Alchemy::LogLevel=0 -config Alchemy::Vector=true -config Alchemy::NoVector=false -config Alchemy::SetjmpAbuse=false -swf cmodule.echotest.EchoTest,800,600,60 echotest.as

    다음으로 만들어진 echotest.swf를 ActionScript 바이트 코드로 만들어주고 라이브러리와

    $ GetABC2.pl echotest echotest.swf.abc

    $ALCHEMY_HOME/achacks에 있는 swctmpl.swf를 위에서 만든 abc로 대체해 새로운 swf를 만들고 SWF 버전 태그를 10으로 한다.

    $ PutABC2.pl $ALCHEMY_HOME/swctmpl.swf temp.swf echotest.swf.abc cmodule/echotest/CLibInit 
    $ V10SWF.pl temp.swf library.swf

    마지막으로 다음과 같은 catalog.xml과 함께 최종적으로 SWC를 만든다.

    <? xml version = "1.0"encoding = "utf-8"?>
    <swc xmlns = "http://www.adobe.com/flash/swccatalog/9">
      <versions>
        <swc version = "1.0" />
        <flex version = "2.0"    build = "143452"/>
      </ versions>
      <features>
        <feature-script-deps />
        <feature-files />
      </ features>
      <libraries>
        <library path = "library.swf">
          <script name = "cmodule/echotest/ CLibInit" mod = "1177909560000">
            <def id = "cmodule.hello:CLibInit" /> 
            <dep id = "Date"    type = "e"/> 
            <dep id = "Date"    type = "s"/> 
            <dep id = "flash.utils : Dictionary" type = "e"/> 
            <dep id = "flash.utils : Dictionary" type = "s"/> 
    :
    (생략)
    :
            <dep id = "AS3" type = "n"/> 
            <dep id = "Object" type = "i"/> 
          </ script>
        </ library>
      </ libraries>
      <Files>
      </ files>
    </ swc>

    $ zip echotest.swc catalog.xml library.swf

     

    이처럼 Alchemy를 통해 얻는 결과물은 일반적으로 SWC이다(SWF의 경우 사용가치가 떨어진다.). 이 SWC는 Flex 3(Flash Player 10을 겨냥해서 만들어져야 함), Flex 4(아직 개발중인 “Gumbo”) 그리고 Flash CS4에서 사용할 수 있다.

     

    C와 C++로 만들어졌기 때문에 Alchemy로 컴파일 된 SWF가 일반 C/C++의 규칙과 제한을 따른다고 생각하면 곤란하다. C/C++는 일반 SWF와 같이 Flash Player의 보안샌드박스안에 포함되고 모든 화면출력결과물은 display list를 통과하도록 만들어진다. 그리고 네트워크 및 파일엑세스도 이미 존재하는 클래스를 사용하게 된다. Alchemy로부터 컴파일된 라이브러리에서 만들어진 코드는 적절한 메모리 덩어리를 ByteArray로 할당한다. 이것은 Alchemy가 어떻게 포인터, malloc, free등이 ActionScript 에서 어떻게 작업되는가 알려주는 개념이 된다. 이말은 즉 C/C++언어가 Alchemy를 통해 100% ActionScript 3.0으로 변경되어 원천적으로 가지고 있는 SWF의 제약사항을 넘어갈 수는 없다는 것을 의미한다.

     

    그럼에도 불구하고 Alchemy의 AVM2 코드가 Flash 와 Flex에서 만들어진 AVM2 코드보다 어떻게 수행속도가 빠를 수 있는지 궁금할 거다. 실제로는 더 빠르지 않다. 그럼 Adobe 에서 주장하는 “수행속도가 빠를 것이다”라는 것은 거짓말인가? 100% ActionScript 3.0으로 바뀌는데 수행속도가 빠를 수 없다고 생각할 수 있다. 하지만 이 부분에서 수행속도의 개선을 찾으면 안된다. 실제로는 Alchemy의 LLVM은 많은 최적화를 이루는 반면 Flash와 Flex의 컴파일러는 최적화 과정이 없다. 또한 Alchemy는 ActionScript 3.0 자체가 가지는 오버헤드의 문제로 인한 수행속도 저하를 극복하는데 쓰일 수 있다.

     

    그럼 Alchemy의 수행속도에 대해 기대할 수 있는 부분은 구체적으로 무엇일가? 바로 메모리 엑세스와 함수 호출이다. Alchemy를 통해 컴파일된 코드는 ByteArray를 적용하기 위해 Flash Player 10에 적용된 새로운 ByteArray를 사용한다. 마치 이것은 RAM처럼 이용된다. ActionScript 3.0의 함수를 호출할 때 그들의 인자가 박싱(boxed) 와 언박싱(unboxed)를 하게 된다. 하지만 Alchemy로 만들어진 코드는 그러한 과정이 없다. 이 두가지 이유로 Alchemy로 만들어진 결과물이 수행속도 향상에 도움이 될 수 있다는 것이다.

     

    ActionScript 코드와 Alchemy 코드간에 통신과정에서 수행속도가 떨어질 수 있다. 이 과정은 마샬링(marshaling)이 된다. 마샬링은 어떤 한 언어에서 작성된 출력 데이터를 다른 언어의 입력단으로 전달해야하는 경우 데이터 변환과정이 생기는 것을 말하는데 ActionScript 코드와 Alchemy 코드간에 빈번한 상대방의 함수 호출은 이런 과정으로 인해 전체적인 수행속도를 죽이는 일을 발생시킬 수 있다. 그러므로 어떤 처리를 위해 C/C++코드에서 한꺼번에 처리하는 과정이 들어가도록 코딩하고 상대방 함수로 넘겨주는 파라미터의 수를 줄여주는 것이 속도향상에 도움이 될 것이다.

     

    Alchemy는 매우 강력하지만 마법사는 아니다. Alchemy의 이점이 무엇인지 잘 파악해서 사용하는 것이 현명하다. 본인이 생각할 때 Alchemy를 사용해야 하는 경우는 다음과 같다.

    1. Alchemy로 포퍼먼스 향상에 어느 정도 이득이 있는 경우
    2. 기존 C/C++ 라이브러리를 ActionScript 3.0으로 바꾸기 힘들거나 별도의 변경 없이 그래로 Flash/Flex/AIR 프로젝트에서 사용하고 싶은 경우

    위 2가지 경우 중 1가지라도 있다고 판단하면 Alchemy를 활용해서 자신의 Adobe RIA 프로젝트에 접목시킬 수 있다고 생각한다. 2번째의 경우 C/C++ 개발자와 Adobe RIA 개발자간에 협업도 기대할 수 있는 부분이다.

     

    한가지 더 언급할 것은 Alchemy는 아직 정식 배포상태가 아니라는 점이다. 그래서 약간 개발하기도 불편하고 버그도 간혹 보인다. 하지만 정식 배로가 된다면 그러한 문제점은 해결될 것이라 생각하고 지금까지 보여줬던 것 보다 더욱 큰 포퍼먼스 향상을 기대할 수 있다. 추후에는 Flash Catalyst에 포함되어 개발에 큰 도움이 될 것이다.

     

    정리하며

     

    Alchemy의 장점은 메모리 엑세스와 함수호출에 따른 수행속도의 개선과 기존 C/C++ 라이브러리를 그대로 활용할 수 있다는 점에 있다. 이 장점을 잘 살려서 현업에 적용할 수 있도록 적절한 예제를 찾아보려한다.

     

    이 글을 적으면서도 Alchemy의 컴파일 과정 및 내용에 대해서 확실히 이해할 수 없었다. 하지만 실망하지 않는다. 어쨌던 이러한 노력은 나중에 큰 도움이 될 것이다라고 생각하기 때문이다.

     

    이 글을 보신 분 중 공유할 수 있는 내용이나 지적사항이 있다면 언제든지 댓글 환영한다. ^^


    한국에도 Alchemy를 활용한 많은 예제와 현업에서 적용 예가 많이 나왔으면 한다.

     

    참고내용

     

    아래 테스트 코드는 문제가 있었습니다. 왜냐하면 GCC 최적화 옵션에 대해서 명확히 이해를 못하고 사용했기 때문입니다. 그래서 잘못된 지식을 전하는 것을 우려해 그냥 내용만 훑어보시되 “Adobe Alchemy 수행속도 테스트와 깊이 이해하기”글을 덧붙여 읽어주시길 바랍니다. 제가 잘못된 내용을 적었다면 지적해주셨으면 합니다. 그리고 실무에 썼거나 테스트를 해보신 분이라면 그에 대해 소개도 부탁드릴께요.

    Alchemy는 C/C++ 코드를 AVM2(ActionScript 3 Virtual Machine) 환경에서 동작하도록 해주는 도구이다. Alchemy를 이용해 기존에 있는 C/C++ 코드를 Adobe AIR, Adobe Flex, Adobe Flash 프로젝트에서 직접 활용할 수 있는 SWF 또는 SWC를 만들어낼 수 있다. 이에 대한 더욱 자세한 사항은 본인이 게재한 “C/C++와 Flash 플랫폼과의 만남. Alchemy 1부” 를 참고하기 바란다.

     

    이 글은 Alchemy를 이용해 만들어진 SWC를 이용했을 때와 순수 ActionScript 3.0으로만 코딩했을 때 수행속도 차이를 비교해보는 것을 목적으로 한다.

     

    Alchemy 속도 테스트

     

    과연 Alchemy를 이용해서 C언어를 SWC로 변환한 코드의 수행속도에 진전이 있을까? 아래 c코드와 ActionScript 3.0 코드는 이를 테스트할 수 있도록 한다. c언어와 ActionScript 3.0에서 동일하게 ”sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3)” 식을 1백만번 반복한다.

     

    컴파일하고 수행하는 방법은 “C/C++와 Flash 플랫폼과의 만남. Alchemy 1부”를 참고한다.

    1. speedtest.c

    #include <math.h>
    #include "AS3.h"

    static AS3_Val c_speed_test(void* self, AS3_Val args)
    {
        int i;
        double result;
        for( i=0; i < 1000000; i++ )
        {
            result = sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3);
        }
        return AS3_Number(result);
    }

    int main()
    {
        AS3_Val method = AS3_Function( NULL, c_speed_test );
        AS3_Val result = AS3_Object( "c_speed_test: AS3ValType", method );
        AS3_Release( method );
        AS3_LibInit( result );
        return 0;
    }

     

    2. AlchemySpeedTest.as

    package {
        import cmodule.speedtest.CLibInit;

        import flash.display.Sprite;
        import flash.display.StageAlign;
        import flash.display.StageScaleMode;
        import flash.text.TextField;
        import flash.text.TextFieldAutoSize;
        import flash.text.TextFormat;
        import flash.utils.getTimer;

        public class AlchemySpeedTest extends Sprite
        {
            public function AlchemySpeedTest()
            {
                stage.scaleMode = StageScaleMode.NO_SCALE;
                stage.align = StageAlign.TOP_LEFT;

                var loader:CLibInit = new CLibInit();
                var lib:Object = loader.init();
                var startTime:Number;

                startTime = getTimer();
                var cResult:String = "c returned value : " + lib.c_speed_test(null) + " delay time(ms) : " + (getTimer()-startTime);

                startTime = getTimer();
                var asResult:String = "as3 returned value : " + as3_speed_test() + " delay time(ms) : " + (getTimer()-startTime);

                var textField:TextField = new TextField();
                textField.text = cResult + "\n" + asResult;
                textField.width = 500;
                textField.autoSize = TextFieldAutoSize.LEFT;
                textField.wordWrap = true;
                textField.defaultTextFormat = new TextFormat( null, 12 );
                addChild(textField);

            }
            public function as3_speed_test():Number
            {
                var i:int;
                var result:Number;
                //var sin:Function = Math.sin;
                //var cos:Function = Math.cos;
                for (i = 0; i < 1000000; i++)
                {
                result = Math.sin( 0.332 ) + Math.cos( 0.123 ) + Math.tan( 0.333 ) * Math.log(3);
                }
                return result;
            }
        }
    }

     

    speedtest.c를 아래처럼 Alchemy로 컴파일하고 만들어진 speedtest.swc를 AlchemySpeedTest.as와 함께 mxmlc로 컴파일 한다.

    gcc speedtest.c –swc –o speedtest.swc
    mxmlc.exe –library-path+=speedtest.swc –target-player=10.0.0 AlchemySpeedTest.as

    아래는 위 프로그램을 시행한 결과이다.

    c returned value : 1.6983678388082433 delay time(ms) : 559
    as3 returned value : 1.6983678388082433 delay time(ms) : 694

    이 결과는 의외의 결과이다. C와 ActionScript 3.0과 같은 수행속도를 보였기 때문이다. 하지만 이 결과는 C코드를 컴파일 할 때 최적화하지 않았기 때문이다. 아래처럼 –03 –Wall 옵션을 넣고 다시 수행해보자. -O3는 최적화 옵션이고 –Wall(또는 –W)는 모든 경고를 출력하도록 한다.

    gcc speedtest.c –03 –Wall –swc –o speedtest.swc
    mxmlc.exe –library-path+=speedtest.swc –target-player=10.0.0 AlchemySpeedTest.as

    컴파일한 SWF파일을 실행한 결과는 다음과 같다.

    c returned value : 1.6983678388082433 delay time(ms) : 1
    as3 returned value : 1.6983678388082433 delay time(ms) : 601

     

    결론

     

    위 실험 결과를 통해 Alchemy를 이용해 C/C++의 수행속도를 잘 활용하면 좋다는 것을 알 수 있었다. 가령, ActionScript 3.0으로 구동 시에 많은 부하가 있을 가능성이 있는 부분을 C로 만들어 Alchemy를 통해 최적화된 SWC로 라이브러리화 해서 사용한다면 여러분의 Flash/Flex/AIR 애플리케이션의 속도를 크게 향상시킬 수 있다. 구체적으로 Audio/Video, 데이터 형식 변환, 데이터 조작, XML 분석 및 암호화 기능, 물리 시뮬레이션등이 들어가는 코드에서 포퍼먼스 향상을 기대할 수 있겠다.

    아래는 Alchemy가 C/C++코드를 ActionScript 3.0 코드로 완벽하게 변경하는가에 대한 의견이다.

    (글쓴이 의견)

    어떤 분은 Alchemy로 SWF를 만들어준다고 해서 C/C++코드가 전부 ActionScript 3.0으로 변환될 것이다라는 생각을 가질 수 있다. 하지만 실험 결과만 가지고 볼 때 틀리다는 것을 유추할 수 있다. Alchemy는 C/C++ 코드를 AVM2 환경에서 동작하도록 만들되 ActionScript 3.0과 함께 사용할 수 있도록 만들어준다. 즉 C/C++를 적절하게 변경하고 ActionScript 3.0과 통신할 수 있는 통로구를 마련해주는 것이 Alchemy의 목적이다. 만약 ActionScript 3.0으로만 변경되는 것이라면 빠른 수행속도를 기대하기 어려울 것이다.

    (양병규님 의견)

    컴파일러에 대해서 조금 관심을 가져보시면 알 수 있을텐데요…
    음… 뭐랄까…
    그 최적화라는 것이 불필요한 일은 안하고 같은 기능이라면 더 빠른 기능으로 대치하고.. 그런일을 하는 것이 컴파일러의 최적화인데요..
    제가 보기에는
    for( i=0; i < 1000000; i++ )
    {
    result = sin( 0.332 ) + cos( 0.123 ) + tan(0.333) * log(3);
    }
    이 부분이.. 최적화를 하면 루프를 1000000번 돌지 않고 한방에 끝낼것같습니다. 최적화알고리즘중에서 루프문안에서의 내용이 반복을 해도 변화가 없는 경우에는 루프를 한방에 끝내도록 하는 알고리즘이 있습니다. 이 예가 그런 예일것 같은데요..

    암튼.. ActionScript에는 그런 최적화가 없는데 이미 오랜 역사동안 만들어진 C/C++언어의 최적화 기술이 적용되면 분명히 나은 결과를 보일 것 으로 예상됩니다. ^^;(물론 코딩하는 사람의 실력이 좋을 수록 최적화의 효과가 떨어지겠지만)

    그리고..
    저는 아무리 봐도 C/C++로 코딩한 것이 결국 몽땅 ActionScript로 만들어지는 것이 맞는 것 같습니다. SWF에는 ActionScript 이 외에 다른 실행코드는 존재하지 않습니다. 최종적으로 만들어진 결과가 *.SWF(*.SWC)이지 않습니까? SWF File Format Specification Version 10 문서 278페이지를 다 훑어봐도 ActionScript 이외에는 실행코드가 없습니다. 머.. DLL을 임포트한다거나 별도의 실행코드용 외부 라이브러리가 있다거나… 그런건 전혀 없습니다.

    malloc 함수 같은 경우의 예를 들어보면 ActionScript에는 malloc과 동일한 역할을 하는 어셈블명령은 없습니다. 하지만 ActionInitArray와 같이 긴 변수를 사용할 수 있는 명령으로 ‘구현’은 할 수 있을겁니다. 아마도 그런 방법으로 구현되지 않았나싶습니다.

    어쨋든 Alchemy는 C/C++을 100% ActionScript로 변환해 주는게 맞고.. 함수사용, 변수사용, 최적화, 수학함수의 구현, 각종 기초 알고리즘등 기초적인 부분에서 훨씬 우월하기 때문에 좋은 효과를 나타내고 있는 것으로 생각됩니다.

    시간이 나면 Alchemy에서 만들어진 SWF 파일을 분석해 보면 아주 좋은 공부가 될것같습니다. ^^;

    Alchemy가 유용한 것은 C/C++ 코드를 ActionScript 3.0와 함께 쉽게 사용할 수 있게끔 해주는 것과 C/C++자체가 가지는 빠른 수행속도를 Flash 컨텐츠에서 이용할 수 있는 것으로 생각한다. Alchemy가 앞으로 사용 편의성 향상과 여러 환경에서 문제없이 개발할 수 있도록 개선된다면 Adobe RIA기술이 한 단계 업그레이드 될 것이라 생각한다.

     

    한가지 주의할 사항은 전부 C/C++로 만드는 것은 좋지 못하다. Alchemy를 적용하기에 앞서 본문에서 실험한 것과 같은 방법으로 여러가지 수행 테스트를 해보고 순수하게 ActionScript 3.0으로 한 것보다 큰 포퍼먼스를 기대할 수 있다고 판단했을 때 적용하는 것이 좋다. 때로는 어떤 코드냐에 따라 별로 큰 차이가 없을 수 있기 때문이다.

    국내에 Alchemy를 응용한 많은 예제와 애플리케이션들이 나오길 바란다.

     

    참고할 사이트

     

    이 문서는 Adobe 연구 프로젝트 코드명중 하나인 “Alchemy”에 대해서 소개한다.

     

    Alchemy는 2008년 미국에서 열린 Adobe MAX 컨퍼런스 행사에서 최초로 소개되었고 C/C++ 코드를 오픈 소스 ActionScript Virtual Machine(AVM2)용으로 컴파일 목적으로 연구 중인 프로젝트이다.

     

    Alchemy는 운영체제(OS)에 의존성이 없는 C/C++ 라이브러리를 Flash Player 10 또는 Adobe AIR 1.5에서 실행되는 SWF 또는 SWC 형태로 컴파일할 수 있도록 해준다. 컴파일은 GCC(GNU Compiler Collection)를 이용해 LLVM(Low Level Virtual Machine)으로 변환한 뒤 이것을 AVM 바이트 코드로 변경시켜주는 과정이 들어간다.

    주로 Audio/Video, 데이터 형식 변환, 데이터 조작, XML 분석 및 암호화 기능, 물리 시뮬레이션 등 부하가 일어나는 계산에 응용하면 적합하다. 이러한 계산을 할 때, ActionScript 3.0보다 훨씬 빠르지만 순수한 C/C++ 코드보다 2~10배 정도 느릴 수 있다.

     

    C와 C++로 만들어진 코드는 Alchemy를 통해 ActionScript 3.0 환경에서 사용할 수 있도록 SWF 또는 SWC로 컴파일 되므로 이를 가져다가 Adobe Flex, Flash, AIR 환경에서 개발할 수 있게 된다.

     

    Alchemy로 제작된 결과물은 Flash Player 10이나 AIR 1.5 이상에서 구동되며, Windows, Mac OS X, Linux등의 다양한 운영체제에서 사용할 수 있다.

    현재 Alchemy는 아직 미완성된 버전이다. 정식 배포가 되기 전까지는 개발의 불편함과 발생할 오류 등에 대해 감수할 수 밖에 없다.

     

    이 문서는 총 2부로 나뉘어 쓰여진다. 1부에서는 개발환경 구축 및 간단한 예제 소개를 통해 Alchemy에 대해서 이해하는 것을 목적으로 한다. 2부에서는 간단한 응용을 통해 실무에 어떻게 적용될 수 있는지 알아보도록 하겠다.

    Alchemy은 사전적으로 연금술(鍊金術)이라 불리운다. 비금속을 인공적 수단으로 귀금속으로 전환하는 것을 목표로 삼는 연금술은 그 의미로 봐서는 과학적으로 가능하지 않다. 하지만 인간의 이러한 노력은 과학적 접근을 통해 물질에 대한 명확한 분석을 가능하게 하는데 큰 역할을 했다고 생각한다. Alchemy는 한국어로 알크미 정도로 발음하면 될 것 같다.

    Adobe에서 연구 프로젝트 이름으로 Alchemy라는 용어를 왜 썼을까? C/C++과 Flash를 섞어 금과 같이 가치 있는 것을 만들겠다는 의미가 내포되어 있는 듯 하다.

     

    Alchemy 소개 동영상

     

    Alchemy에 대해서 소개하는 동영상을 보도록 하자. 영어듣기가 어려우신 분들은 뛰어넘어가도 좋겠다.

     

    아래는 Adobe 이벤젤리스트인 라이언 스튜어트(Ryan Stewart)가 Alchemy에 대해서 소개한 동영상을 담고 있다.

    http://tv.adobe.com/#vi+f1472v1033

     

    아래는 Adobe MAX 컨퍼런스 행사에서 Alchemy에 대해서 소개하는 동영상이다.

     

    http://kr.youtube.com/watch?v=0hX-Uh3oTcE

     

    아래는 Automate Studios의 최고기술경영자이자 최고 소프트웨어 설계 책임자인 Brandel Hall이 Alchemy를 소개하는 동영상이다.

     

    http://labs.adobe.com/technologies/alchemy/videos/brandenhall/

     

    Alchemy를 이용하여 C코드를 Flash로 변환한 게임 : Doom 1

     

    Alchemy에 대한 흥미를 돋구기 위한 것으로 이것만 한 것이 없는 것 같다. 93년 작품인 DOS에서 돌아갔던 Doom 1이다. 아래 그림은 C코드로 만들어진 Doom 게임을 Alchemy를 이용해 Flash로 변환하여 실행한 모습을 스크린샷 한 것이다.

     

    이처럼 Alchemy를 이용하면 기존 C/C++코드를 다양하게 활용할 수 있다.
    아래 링크를 통해 Doom 1을 실행해자.

    이 코드는 제작자가 Alchemy 개발환경에서 직접 컴파일할 수 있도록 소스를 공개해두었다.

    Doom 게임을 직접 Flash 기반으로 포팅하는 소스도 공개가 되어 있다 참고하길 바란다. 이것은 Alchemy와 상관이 없다.

     

    Alchemy 활용을 위한 지침

     

    1. 기존 C/C++ 코드 이용

    이미 C/C++로 만들어진 코드가 많이 있다. 암호화 알고리즘이나 압축 알고리즘 등은 이미 C/C++로 만들어져 있는데 이러한 코드를 일일히 ActionScript 3.0으로 바꾼다는 것은 비능률적이다. Alchemy는 이용하면 기존 C/C++ 코드를 쉽게 ActionScript 3.0에서 활용할 수 있는데 큰 도움을 줄 수 있다.

    2. C/C++로 최적화

    C/C++은 ActionScript 3.0보다 더 최적화된 코드를 만들어낼 수 있다. 가령 ByteArray를 다루는 일이나 많은 연산을 처리하는 작업에서 큰 포퍼먼스 향상을 기대할 수 있다. 게다가 C/C++ 특성상 직접 메모리 관리가 된다. 이러한 이유로 복잡한 Audio/Video 데이터 형식 변경 및 데이터 조작, 속도를 요하는 과학 시뮬레이션 핵심 코드 등에 적절하게 활용하면 매우 유용하게 쓸 수 있다. 구체적으로 복잡한 연산은 C/C++이 담당하고 렌더링은 ActionScript 3.0이 담당하게 한다면 전체 ActionScript 3.0으로 구현하는 것보다 몇 배의 포퍼먼스 향상도 기대할 수 있다. C/C++로 만들어진 코드와 ActionScript 3.0 간에 빈번한 통신은 오히려 속도를 저해시키는 요인이 될 수 있으며 제작만 어려워지는 상황이 발생할 수도 있으니 잘 구분해서 활용해야겠다.

    3. C/C++로 만들었기 때문에 다 할 수 있는 것은 아니다.

    C/C++을 이용하지만 AVM 환경에서 돌아가는 것을 목적으로 하기 때문에 몇가지 제약이 따른다. 가령 Win32 API 기반의 C코드나 DirectX 코드를 변환해 사용할 수 없다. 또한 Flash Player의 보안샌드박스에 위반하는 작업도 할 수 없다.

     

    Alchemy 입문을 위한 참고 사항

     

    Alchemy를 사용하기 위해 다음 항목을 참고하면 되겠다.

    1. Alchemy는 Flash Player 10 환경 및 Adobe AIR 1.5 Runtime 환경에서 동작하므로 해당 프로그램을 다운로드 받는다.
    2. 자신의 운영체제(Windows/Mac OSX/Linux 지원)에 맞는 Alchemy 툴킷(toolkit)을 다운로드 받는다.
    3. Getting Stated 문서를 통해 Alchemy 설치 및 사용방법을 익힌다. 이 문서에는 Alchemy 설치방법과 C/C++코드를 SWC로 변환하는 방법, 그리고 SWC를 이용한 간단한 ActionScript 3.0 예제를 보여준다.
    4. 질문이나 정보공유를 위해 Alchemy 포럼 페이지를 이용한다.
    5. Alchemy에 대한 간단한 라이브러리를 다운로드 받을 수 있고 또한 라이브러리 공유를 할 수 있다.

     

    Alchemy 시스템 요구사항

     

    Alchemy 개발환경을 구축하기 위해 운영체제 별로 다음과 같은 사양을 요구한다.

    1. Windows

    Window XP SP2(본인은 SP3)에서만 테스트 되었다. Vista의 경우는 테스트 되지 않았다. 다음 패키지들이 요구된다.

    • Cygwin 개발 도구
    • Java 1.4 이상
    • Perl(또한 Compress::Raw::Zlib 패키지를 설치해야 한다.)
    • Flash Player 10
    • 기타추가사항 : Adobe AIR 1.5 이상 런타임, Adobe AIR 1.5 SDK 이상 또는 Adobe Flex SDK 3.2 이상

    2. Mac OSX

    Mac OSX 환경에서는 다음 패키지들이 필요하다.

    • Perl 5.8 이상(Compress::Raw::Zlib.pm 포함)
    • Java 1.5 이상
    • Xcode 3.0 이상
    • Flash Player 10 이상
    • 기타추가사항 : Adobe AIR 1.5 이상 런타임, Adobe AIR 1.5 SDK 이상 또는 Adobe Flex SDK 3.2 이상

    3. Linux

    Ubuntu 8.0.4 버전에서만 테스트 되었다. 다음 패키지가 필요하다.

    • Java 1.4 이상
    • Perl(또한 Compress::Raw::Zlib 패키지를 설치해야 한다.)
    • Flash Player 10 이상
    • 기타추가사항 : Adobe AIR 1.1 beta 런타임, Adobe AIR 1.1 beta SDK와 Flex SDK 3.2 이상

     

    Microsoft Windows에서 Alchemy 설치

     

    MS Windows XP 환경에서 설치 방법을 설명하겠다. 물론 Mac OS X나 Linux환경에서도 가능하다. Mac OS X와 Linux에서는 gcc 개발이 가능하므로 Windows와 달리 Cygwin과 같은 프로그램을 설치할 필요가 없다는 점이 편리하다.

     

    1. 설치 요구사항(MS Window 환경인 경우)

    2. Cygwin 설치

    Cygwin을 다운로드 받아 설치한다. Cygwin은 Window 상에서 Linux와 비슷한 환경을 제공해주는 프로그램이라고 할 수 있다. 그러므로 Linux환경에 어느 정도 경험있는 사람이라면 Cygwin도 쉽게 적응할 수 있을 것이다. Window환경에서 Alchemy를 동작시키기 위해서는 Cygwin이 필요하지만 Linux, Mac OS X에서는 필요없다.

     

     

    인터넷을 이용해 설치하도록 한다.

     

     

    설치할 폴더를 지정한다.

     

     

    설치를 위한 패키지 파일을 다운로드로 하기 위한 임시 폴더를 지정한다.

     

     

    인터넷 연결을 선택한다. Direct Connection을 선택해 사용하면 되겠다.

     

     

    패키지를 다운로드 할 미러 사이트를 선정한다. daum.net에서 지원하므로 이용하자.

     

    아래와 같이 Select Packages가 뜨면 필요한 패키지를 선택해 설치할 수 있도록 한다.(앞서 Perl, zip, gcc/g++, vi 에디터를 설치해야 한다고 언급했다.)

     

    먼저 Devel 카테고리에 [+]기호를 눌러 펼친 다음 아래에 살펴보면 Package이름으로 gcc-core: C Compiler와 gcc-g++: C++ Compiler가 있다. 해당 패키지에 Skip으로 된 문자를 클릭해서 3.4.4-3과 같이 버전이 표시되도록 한다. Skip은 설치에서 제외한다는 의미이다.

     

     

    다음으로 Perl 카테고리의 Default를 클릭하면 Install로 변한다. 이렇게 해서 하위에 있는 Perl관련 패키지들이 전부 설치될 것이다.

     

     

    zip 패키지를 설치하기 위해 Archive 카테고리 [+] 버튼을 눌러 펼친 다음 zip: A file compression and packaging utility compatible with PKZIP 을 찾아 Skip을 클릭하여 2.32-2로 바꾸도록 한다.

     

     

    vi 에디터를 사용하기 위해 Editors 카테고리의 [+] 버튼을 눌러 아래에 vim: Vi IMproved를 찾은 뒤 Skip을 눌러 7.2-3로 바꿔 설치할 수 있도록 한다.

     

     

     

    다음 버튼을 눌러 설치를 한다.

     

     

    Cygwin 설치가 완료되었다.

     

     

    설치가 완료되면 바탕화면에 아래와 같은 실행 아이콘이 생길 것이다.

     

     

    설치는 C드라이브에 설치되었다. 설치된 cygwin 내부를 살펴보면 디렉토리 구조가 Linux와 비슷하다는 점이 흥미롭다.

     

     

    Cygwin에 다른 패키지를 설치하고 싶을 때는 Cygwin 홈페이지로 가서 설치 실행파일 다운로드 받아 앞서 했던 것을 반복하면 되겠다. 물론 이전 설치한 것은 굳이 재설치할 필요 없다.

     

    Cygwin의 자세한 사용법은 Java를 설치 후 해보도록 하자.

     

    3. Java 설치

    Windows 환경에서 Alchemy는 Java 환경이 구축되어 있어야 한다. 참고로 MAX OS X의 경우에는 Xcode 2.4+ 버전이 필요하다.

    http://java.sun.com/javase/downloads/index.jsp

    상단 페이지로 가서 Java Standard Edition Develop Kit(JDK)를 Windows용으로 다운로드 받아 설치한다.

     

    설치 후 환경 변수를 설정해야 한다. 환경 변수를 설정하는 이유는 운영체제에 Java가 설치된 경로를 등록함으로써 DB나 다른 프로그램과의 연동에 대한 편의성을 제공할 수 있기 때문이다. Linux나 Max OC X에도 이러한 환경 변수 설정이 있으니 인터넷 검색을 통해 찾아보길 바란다.

     

    내컴퓨터->(마우스 오른쪽 클릭)속성->고급으로 들어간 다음 환경변수 버튼을 클릭한다.

     

     

    아래처럼 환경변수 설정 창이 나온다.

     

     

    위 화면에 사용자 변수와 시스템 변수가 있다. 사용자 변수는 로그인한 사람에게만 적용하기 위한 것익 시스템 변수는 전체 사용자에게 적용하는 변수라고 생각하면 되겠다. 시스템 변수에서 새로 만들기 버튼을 누른 다음 다음처럼 변수값을 등록한다.

    • 변수 이름 :  JAVA_HOME
    • 변수 값 :   JDK가 설치된 경로를 넣으면 되겠다.

     

    다음으로 시스템 변수 중에 Path를 선택하여 편집 버튼을 누르면 다음과 같은 창이 뜬다.  아래처럼 변수 값으로 %JAVA_HOME%\bin; 를 앞부분에 추가한다.

     

    CLASSPATH 시스템 변수를 등록한다. 시스템 변수에서 새로 만들기 버튼을 눌러 아래와 같이 입력한다.

    • 변수 이름 : CLASSPATH
    • 변수 값 : %classpath%;

     

    모두 입력했으면 확인 버튼을 눌러 변수 설정을 종료한다.

     

     

    위에서 설정한 환경 변수가 제대로 설정되어 있는지 확인하기 위해 콘솔창을 띄운다. 시작->실행->cmd입력->확인하면 되겠다.

     

     

    cmd 창에서 아래와 같이 “java –version”, “javac –version”을 입력했을 때 에러 없이 잘 보여준다면 제대로 환경변수가 설정된 것이다.

     

    이로써 Java 설치를 마친다.

    4. Java를 설치한 뒤에 Cygwin 터미널 실행.

    Cygwin은 Linux환경과 비슷하다. 윈도우에서 돌아가는 Linux라고 생각하고 접근하면 되겠다. 아래처럼 “ls –al”, “pwd”등으로 자신의 계정에 있는 파일 정보를 볼 수 있다.

     

    각각의 드라이브에 접근 할 수 있다. 가령, C드라이브에 접근하기 위해 “cd /cygdrive/c”을 입력하면 된다.

    이처럼 Cygwin을 이용하면 Window에서 Linux와 비슷한 환경이 제공된다. 그러므로 Linux 환경을 접해본 사람이라면 Cygwin을 다루는데 그리 어렵지 않을 것이다.

     

    5. Flex SDK 설치

    Flex SDK를 다운로드 받아서 C 드라이브에 설치하자. Flex SDK 3.2 이상 버전이어야 한다. Flex Builder 3를 이미 설치한 사람은 C:\Program Files\Adobe\Flex Builder 3\sdks 안에 SDK 3.2 가 있을 수 있겠다. 편의성을 위해 아래처럼 C 드라이브안에 flexsdk 이름으로 만들어 두자.  이 폴더는 Cygwin에서 접근하면 “/cygdrive/c/flexsdk”이 된다. 자유롭게 다른 경로에 설치할 수 있으므로 앞으로 /cygdrive/c/flexsdk를  $FLEX_HOME 별칭을 사용하겠다.

     

    Cygwin에서는 Linux 명령어인 ls로 C 드라이브 내용을 볼 수 있다. 가령 “ls /cygdrive/c/flexsdk/”를 입력하면 금방 C드라이브에 설치한 flexsdk 내용을 확인할 수 있겠다.

     

     

    6. Alchemy 다운로드 및 설치

    http://labs.adobe.com/downloads/alchemy.html

    위 링크로 들어가서 Windows Alchemy Toolkit을 다운로드 받는다. 다운로드 받은 다음 압축을 푼다. 본인은 편의성을 위해 cygwin 설치폴더 내에 alchemy폴더를 만들어 다운로드 받은 Alchemy Toolkit 파일을 복사했다. C:\cygwin\alchemy 를 Cygwin에서는 /alchemy/로 접근할 수 있으므로 앞으로 /alchemy/를 $ALCHEMY_HOME 으로 별칭을 두어 사용하겠다.

     

    7. Alchemy 환경설정

    Alchemy 개발환경 설정은 비교적 간단하다. 몇가지 환경설정만 하면 Cygwin에서 Alchemy 개발환경이 만들어진다. 아래 과정을 진행하면서 주의할 사항은 왜 그렇게 하는가를 따져보면서 읽어보는게 좋겠다. 왜냐하면 이러한 과정은 앞으로 Alchemy 개발환경 적응에 도움이 되기 때문이다.

     

    $ALCHEMY_HOME으로 찾아간다. cd 명령어로 이동하면 되겠다. c:\cygwin\alchemy에 설치했었으므로 “cd /alchemy”로 이동하면 된다. 만약 d 드라이브에 설치했다면 “cd \cygdrive\d\alchemy”로 이동할 수 있다.

     

    $ALCHEMY_HOME 안에는 config 파일이 있다. ls로 확인해보길 바란다.
    아래와 같이 config를 실행하면 된다.

    $ cd /alchemy
    $ ./config

    실행하면 몇 가지 에러 메시지를 보이면서 종료한다.

     

    걱정하지 말자. config를 실행한 이유는 Alchemy설치를 위한 파일을 생성하기 위함이다. 아래처럼 ls로 $ALCHEMY_HOME 폴더 안에 파일목록을 살펴보면 전에 없었던 alchemy-setup 파일이 생성된 것을 확인할 수 있다.

     

    Cygwin 설치할 때 vi 에디터를 설치했다. 그러므로 다음 명령어로 alchemy-setup 파일을 수정할 수 있다. 혹시 vi 에디터를 설치하지 않았다면 다른 에디터를 이용하길 바란다. 단, 외부에서 수정시 수정할 파일은 chmod를 이용해 권한 설정을 해주어야 편집이 가능하다.

    $ cd /alchemy
    $ vi alchemy-setup

    아래와 같이 alchemy-setup내에 Flex SDK에 포함된 ADL(AIR Debug Launcher)을 추가하도록 한다.

    export FLEX_HOME=/cygdrive/c/flexsdk
    export ADL=$FLEX_HOME/bin/adl.exe

     

    alchemy-setup 파일 설정을 마쳤다. 이번에는 자신의 계정으로 돌아가서 숨김 파일인 .bashrc 파일을 연다. 본인의 경우 /home/jidolstar 가 개인 계정이므로 해당 계정으로 이동한 다음 vi 에디터로 .bashrc를 열도록 하겠다.

    $ cd /home/jidolstar
    $ ls –al
    $vi .bashrc

    .bashrc 맨 아래에 아래와 같이 입력한다. 단 alchemy 설치 경로는 c:\cygwin\alchemy 일 때를 가정한다.

    source /alchemy/alchemy-setup
    PATH=$ALCHEMY_HOME/achacks:$FLEX_HOME/bin:$PATH
    export PATH

     

    환경설정 PATH로 $ALCHEMY_HOME/achacks 와 $FLEX_HOME/bin을 등록했다.

    $ALCHEMY_HOME/achacks은 Alchemy에 사용하는 gcc 또는 g++ 툴이 존재한다. 즉 Cygwin에서 제공하는 gcc대신 Alchemy용 전용 gcc를 활용하기 위한 환경설정인 것이다. .bashrc에 설정을 했으므로 본인 계정으로 접속한 경우에는 항상 Alchemy 전용 gcc를 이용하게 되는 것이다. 만약 때에 따라서 Cygwin에서 제공하는 gcc를 이용할 경우가 있다면 $ALCHEMY_HOME/achacks는 빼고 alc-on와 alc-off 명령을 이용해 필요할 때마다 Alchemy 전용 gcc와 Cygwin gcc를 번갈아 가면서 이용할 수 있다.

     

    alc-on, alc-off를 좀더 이해하기 위해 설명을 덧붙이겠다. 앞서 설정한 alchemy-setup을 유심히 봤다면 그 안에 아래와 같은 코드를 볼 수 있었을 것이다.

    alias alc-home=’cd $ALCHEMY_HOME’
    alias alc-on=’export PRE_ALCHEMY_PATH=$PATH; export PATH=$ALCHEMY_HOME/achacks:$PATH’
    alias alc-off=’export PATH=$PRE_ALCHEMY_PATH’

    별칭(Alias)으로 alc-home, alc-on, alc-off를 지정한 것을 볼 수 있다. cygwin 콘솔창 안에서 이들 명령을 시행하면 해당 명령시 실행한다. alc-home의 경우 Alchemy가 설치된 홈으로 이동한다. alc-on은 Alchemy 전용 gcc를 이용하도록 경로를 수정해준다. 그리고 alc-off는 Cygwin gcc를 이용하도록 한다. 단 alc-on 전에 alc-off를 사용해버리면 모든 경로정보가 사라지게 된다. 이런 경우에는 Cygwin을 종료했다가 다시 실행하면 되겠다.

     

    $FLEX_HOME/bin은 /cygdrive/flexsdk/bin에 있는 flex 컴파일러인 mxmlc.exe를 어느 경로에서든 실행할 수 있게 하기 위함이다. 이 환경설정은 사용하는 것이 좋겠다. 그렇지 않으면 Flex 컴파일을 위해 mxmlc.exe가 있는 경로를 찾아가야 할 것이다.

    Alchemy 설정을 모두 마쳤다. 설정이 적용될 수 있도록 Cygwin을 종료했다가 다시 실행하면 설정이 적용된다.

     

    Alchemy 예제 테스트

    Alchemy를 테스트 해보기 위해 Alchemy 설치시 이미 포함되어 있는 예제 프로그램을 이용해 보겠다. C, ActionScript 코드에 대한 자세한 설명은 배제하고 Alchemy를 이용하는 방법만 소개한다. 필요하다면 예제 프로그램을 스스로 분석하는 것이 도움이 될 것이다. 본 예제는 Adobe 이벤젤리스트인 마이크 챔버스(Mike Chambers)에 의해 작성되었다.

     

    1.  C언어로 작성된 코드를 Alchemy를 이용해 SWC로 컴파일하기

    먼저 $ALCHEMY_HOME/samples/stringecho 로 이동한 뒤 gcc를 이용해 해당 코드를 SWC 파일로 컴파일 해보자.

     

    $ALCHEMY_HOME/samples/stringecho 안에는 아래 코드와 같은 stringecho.c가 존재한다. 이 코드의 역할은 매우 단순하다. 코드를 대충봐도 알겠지만 결국 사용할 함수는 echo()이다. AS3_로 붙은 함수들은 모두 Alchemy C 라이브러리에서 제공하는 함수들임을 예상할 수 있겠다.

    //Simple String Echo example
    //mike chambers
    //mchamber@adobe.com

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

    //Header file for AS3 interop APIs
    //this is linked in by the compiler (when using flaccon)
    #include <AS3.h>

    //Method exposed to ActionScript
    //Takes a String and echos it
    static AS3_Val echo(void* self, AS3_Val args)
    {
        //initialize string to null
        char* val = NULL;
        //parse the arguments. Expect 1.
        //pass in val to hold the first argument, which
        //should be a string
        AS3_ArrayValue( args, "StrType", &val );
        //if no argument is specified
        if(val == NULL)
        {
            char* nullString = "null";
            //return the string "null"
            return AS3_String(nullString);
        }
        //otherwise, return the string that was passed in
        return AS3_String(val);
    }

    //entry point for code
    int main()
    {
        //define the methods exposed to ActionScript
        //typed as an ActionScript Function instance
        AS3_Val echoMethod = AS3_Function( NULL, echo );

    // construct an object that holds references to the functions
        AS3_Val result = AS3_Object( "echo: AS3ValType", echoMethod );

    // Release
        AS3_Release( echoMethod );

    // notify that we initialized — THIS DOES NOT RETURN!
        AS3_LibInit( result );

    // should never get here!
        return 0;
    }

    위 코드를 SWC로 컴파일하기 위해 다음 명령어를 실행한다. –O3 옵션은 최적화를 위한 것이고 -Wall은 모든 경고 메시지를 보여주기 위함이다. -swc를 붙였으므로 SWC로 만들어질 것이다. –o는 출력파일이름을 지정한다. -O3는 꼭 붙여주는 습관을 가지는게 좋다. 그렇지 않으면 수행속도가 떨어질 수 있다. 최소한 –O2 이상 주도록 하자.

    $ cd /alchemy/samples/stringecho
    $ gcc stringecho.c –O3 –Wall –swc –o stringecho.swc

    위처럼 나오면 컴파일이 완료된 것이고 결과적으로 stringecho.swc가 생성된다. Alchemy에서 컴파일은 다음과 같은 과정을 거친다. 참고만 하도록 한다.

    1. C언어를 LLVM(Low Level Vitual Machine) Byte Code로 변환한다. (확장자 .bc)
    2. LLVM 코드를 ActionScript 3.0 코드로 변환한다.(확장자 .as)
    3. ActionScript 코드를 ActionScript Byte Code로 변환한다.(확장자 .abc)
    4. 마지막으로 swc을 만든다. (확장자 .swc)

    2. 컴파일된 SWC를  ActionScript 3.0 프로젝트에 적용해보기

    $ALCHEMY_HOME/samples/stringecho 안에 컴파일 결과물인 stringecho.swc를 이용해 간단한 ActionSciript에 포함하여 컴파일 해보자.

     

    $ALCHEMY_HOME/samples/stringecho/as3 안에 가보면 EchoTest.as 가 있다. 이 ActionScript 파일은 방금 만든 stringecho.swc에 정의된 echo()함수를 사용한다.

    package
    {
        import flash.display.Sprite;
        import cmodule.stringecho.CLibInit;
        public class EchoTest extends Sprite
        {
            public function EchoTest()
            {
                var loader:CLibInit = new CLibInit;
                var lib:Object = loader.init();
                throw new Error(lib.echo("foo"));
            }
        }
    }

    아래처럼 실행하면 되겠다. 참고로 mxmlc.exe를 바로 실행할 수 있는 이유는 환경설정을 위해 개인 계정에 존재하는 .bashrc 파일에 환경설정시 경로로 $FLEX_HOME/bin 를 설정했기 때문이다.

    $ cd /alchemy/samples/stringecho/as3
    $ mxmlc.exe -library-path+=../stringecho.swc –target-player=10.0.0 EchoTest.as

    –target-player=10.0.0 옵션을 넣은 이유는 Alchemy 결과물은 반드시 Flash Player 10 이상 버전에서 동작할 수 있기 때문이다. 컴파일이 성공하면 아래와 같이 EchoTest.swf가 만들어진다.

     

     

    만들어진 EchoTest.swf를 실행해보면 throw new Error(lib.echo("foo")); 부분 때문에 에러창이 나온다. 아래 창과 같이 “foo”가 나왔다면 제대로 실행된 것이다. 다른 에러가 나왔다면 Flash Player 10인지 확인해보자.

     

    3. 컴파일된 SWC를 Flex 프로젝트에 적용해보기

    이번에는 stringecho.swc를 Flex Builder 3 Profession에서 Flex 프로젝트를 만들어 적용해보도록 하겠다.

     

    아래와 같이 Flex Builder 3 Professional을 실행한 다음 stringecho_test라는 이름으로 Flex 프로젝트를 만들고 libs 폴더에 stringecho.swc를 복사한다.

    그런 다음 아래와 같이 MXML를 작성한다.

    <?xml version="1.0" encoding="utf-8"?>
    <mx:Application
        xmlns:mx="http://www.adobe.com/2006/mxml"
        layout="absolute"
        creationComplete="init();">
        <mx:Script>
            <![CDATA[
                import cmodule.stringecho.CLibInit;
                private function init():void
                {
                    var loader:CLibInit = new CLibInit;
                    var lib:Object = loader.init();
                    throw new Error(lib.echo("foo"));
                }
            ]]>
        </mx:Script>
    </mx:Application>

    이때 아래 2가지 조건이 맞아야 한다.

    첫째. Flex SDK의 버전은 3.2 이상이어야 한다.
    둘째. Flash Player version은 10.0.0 이상이어야 한다.

    이 조건들이 맞지 않으면 에러를 낼 것이다. 에러가 발생한다면 아래와 같이 메뉴에서 Project->Properties로 들어가 창이 뜨면 좌측메뉴에 Flex Compiler를 선택한 뒤 아래처럼 설정한다.

    • Flex SDK version을 Flex SDK 3.2로 선택한다.
    • Compiler Options에 –-target-player=10.0.0 을 삽입한다.
    • HTML wrapper의 Require Flash Player version을 10.0.0으로 맞춘다.

    만약 Flex SDK 3.2가 없다면 다운로드 받아 C:\Program Files\Adobe\Flex Builder 3\sdks 내부에 복사해두고 메뉴에서 Windows->Preferances로 들어가 아래와 같은 새창이 뜨면 좌측 카테고리에서 Flex->Installed Flex SDKs를 선택한다. 우측에 Add버튼을 눌러 sdk경로를 맞춰준 다음 Flex 3.2를 기본으로 선택해준다.

     

     

    위 환경 설정을 모두 맞추면 에러가 발생하지 않을 것이다.

    실행후 아래와 같이 Error: foo 메시지가 나왔다면 프로그램이 제대로 실행된 것이다.

     

     

    Alchemy Tools에 대해

    Alchemy SDK에는 많은 명령 실행을 위한 도구가 포함되어 있다. 여기에는 C/C++파일을 Flash와 호환하기 위한 디버깅 도구 등도 포함한다. 더욱 자세한 내용은 Developing with Alchemy:Tools를 참고하도록 한다.

     

    1. 별칭(Alias)

    $ALCHEMY_HOME 디렉토리 하위에 존재하는 alchemy-setup 파일을 열어 아래 부분에 살펴보면 다음 설정이 존재한다. 이 부분은 별칭(alias)을 설정하는 것으로 alc-home, alc-on, alc-off 을 등록하도록 한다.

    alias alc-home=’cd $ALCHEMY_HOME’
    alias alc-on=’export PRE_ALCHEMY_PATH=$PATH; export PATH=$ALCHEMY_HOME/achacks:$PATH’
    alias alc-off=’export PATH=$PRE_ALCHEMY_PATH’

    alc-home : Alchemy를 설치한 디렉토리로 이동한다. 본 문서에 설치하는 방법대로 설치하면 “cd /alchemy” 한 것과 같은 동작이다.

     

    alc-on/alc-off : Alchemy 동작 On/Off 기능이다. alc-on을 실행하면 $ALCHEMY_HOME/achacks 내에 있는 gcc 빌드 관련 도구를 이용하게 되며 alc-off를 실행하면 원래 gcc를 이용하게 한다.

     

    아래는 alc-home, alc-on, alc-off 명령어를 이용할 때 상태를 보여준다. alc-home 명령어 실행시 Alchemy 설치 디렉토리로 이동한 것을 확인하자. 그리고 alc-on/alc-off 명령어를 실행시에 어떤 gcc를 이용하게 되는지 확인한다.

     

     

    하지만 이 문서대로 착실하게 따라온 사람은 아래처럼 나올 것이다. 그 이유는 .bashrc 파일 설정과 관련 있다. “PATH=$ALCHEMY_HOME/achacks:$FLEX_HOME/bin” 는 강제적으로 $ALCHEMY_HOME/achacks로 경로로 잡아주기 때문에 alc-on, alc-off 명령어가 적용되지 않는 것이다. 만약 alc-on, alc-off 명령을 적용하길 원한다면 $ALCHEMY_HOME/achacks을 빼고 Cygwin을 다시 실행하면 되겠다.

     

     

    환경변수에 경로가 잘 설정되었는지 확인하기 위해 echo $PATH를 아래와 같이 이용해봐도 되겠다.

    2. $ALCHEMY_HOME/achacks 에 포함된 도구

    이 경로에 포함된 도구는 앞서 설명했듯이 gcc 빌드 관련 도구들이다. alc-on 명령어를 실행할 때 사용할 수 있다.

    gcc : 매우 중요한 명령으로 다음과 같은 기능을 수행한다.

    • 라이브러리 경로를 /usr/local을 $ALCHEMY_HOME/usr/local 지정한다.
    • LLVM 바이트코드를 생성하는 llvm-gcc와 llvm-g++를 호출한다.
    • ActionScript를 생성하는 적절한 매개변수를 가지는 llvm 도구를 호출한다.
    • ABC(ActionScript Byte Code) 파일을 생성하기 위해 Alchemy ActionScript 컴파일러를 호출한다.
    • “-swc” 옵션이 있는가 없는가에 따라 ABC파일을 SWF 또는 SWC로 패키지화 한다.
      -swc는 매우 중요한 옵션으로 SWC로 패키지화 한다는 것을 의미한다. 기본값은 실행가능한 SWF를 생성한다. 결과가 exe(실행파일)이지만 실행파일 헤더에 swfbridge와 연결하기 위한 shabang이 있다.

      모든 다른 옵션은 llvm-gcc로 전달된다.

      g++ : 전달된 인수를 그대로 gcc에 전달한다.
      uname : 운영체제가 FreeBSD 6.2에 있는 것처럼 작동한다.
      pkg.pl, tmpl.pl, swctmpl.swf : SWF와 SWC를 생성을 도와주는 역할을 한다.
      기타 다른 스크립트 : 기본적으로 $ALCHEMY_HOME에 대한 경로를 /usr에 맵핑하는 스크립트이다.

     

    3. $ALCHEMY_HOME/bin 에 포함된 도구

    Alchemy 설정을 수행하면 이 경로가 포함이 된다(alchemy-setup과 .bashrc 파일 참고). 사용중인 다른 도구에 간섭받지 않도록 설정되어 있다.

     

    alc-util : Alchemy에 영향을 미치는 환경 변수들을 보여준다. 아래는 실행한 모습이다.

     

    swfbridge : Alchemy에서 생성된 실행 파일을 실행하는데 사용한다. 기본 목적은 ADL(AIR Debug Launcher)를 사용하여 SWF를 시작할 수 있도록 임시 AIR 애플리케이션을 만드는 것이다. 두 번째 목적은 로컬 소켓 연결을 위해 특정 API를 호출하는 것이지만 향후 배포에서 제외될 가능성이 있다.

     

    Alchemy 샘플 디렉토리($ALCHEMY_HOME/samples/HelloFlash)로 가면 아래와 같이 swfbridge를 간단하게 테스트할 수 있는 코드(HelloFlash.c)가 있다. 일반 c코드와 동일하다.

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

    int main(int argc, char* argv[])
    {
        printf("Hello Flash!\n");
    }

    이 코드를 실행하기 위해 다음과 같이 실행한다.

    cd $ALCHEMY_HOME/samples/HelloFlash
    gcc HelloFlash.c
    ./a.exe

     

    이처럼 Alchemy를 통해 생성된 exe파일은 swfbridge에서 실행된다. swfbridge는 exe파일의 head에 있는 shabang에 의해 실행된다.

     

    gluegen : 적은 노력으로 C/C++ 라이브러리를 ActionScript로 만들기 위한 컴파일 도구이다. 확장자가 .gg를 가지며 이를 응용한 예제는 2부에서 소개하도록 하겠다.

    zpipe : 이 도구는 Zlib 압축 알고리즘을 사용하여 표준 입력(STDIN)을 통해 압축 또는 압축 풀기를 하여 표준 출력(STDOUT)으로 내보내는 역할은 한다. 2개의 옵션이 있다. zpipe -h는 도움말을 보여주고 zpipe -d는 압축풀기(decompress)를 하도록 한다.

    예제 : zpipe <uncompressed> compressed

    zpipe.pl : zpipe와 같은 역할을 하지만 Perl과 Compress::Raw::Zlib에서 구현된다. 사용법은 동일하다.

    ExplSWF.pl : 전달된 SWF를 확장한다. SWF의 태그가 현재 디렉토리에 파일로 내보내진다.

    예제 : ExplSWF.pl src.swf

    ImplSWF.pl : 전달된 SWF를 압축한다. 현재 디렉토리 내에 태그 파일이 SWF에 포함된다.

    예제 : ImplSWF.pl dst.swf

    GetABC2.pl : SWF에서 ABC를 추출한다.

    예제 : GetABC2.pl src.swf dst.abc

    PutABC2.pl :원본이 되는 SWF를 주어진 ABC로 대체된 새로운 SWF를 만든다.

    예제 : PutABC2.pl src.swf dst.swf newabc.abc

    PutBIN.pl : 원본이 되는 SWF를 주어진 바이너리 부분으로 대체된 새로운 SWF를 만든다.

    예제 : PutBIN.pl src.swf dst.swf data.bin symname

    ShrSWF.pl : SWF 파일을 압축한다.

    예제 : ShrSWF.pl src.swf dst.swf

    V10.pl : SWF 버전 태그를 10으로 한다.

    예제 : V10.pl src.swf dst.swf

     

     

    1부를 정리하며

     

    지금까지 Adobe Alchemy 개발환경 구축과 함께 간단한 예제 및 Alchemy 도구들에 대해 소개했다. 2부에서는 Adobe Alchemy 공식페이지에서 제공하는 라이브러리를 활용하고 간단한 응용을 통해 Alchemy에 대해 심층적으로 학습해보는 시간을 가지도록 하겠다.

     

    관련 페이지

    추가사항 1 : Alchemy 속도 테스트(잘못된 예제)

     

    이 글을 통해 많은 분들이 Alchemy 수행속도 및 내부구조에 대해서 관심을 보였습니다. 기대에 부응코자 Alchemy가 Flash 애플리케이션에 어느 정도 속도향상을 줄 수 있는가 알아보기 위해 간단한 테스트를 했습니다.

     

      추가사항 2 : Alchemy 속도 테스트 및 깊이 이해하기

      제가 GCC에 대해서 별로 접근해본 적이 없어서 위 Alchemy 속도 테스트에서 잘못된 예제를 보여드렸네요. 최적화에 대한 잘못된 지식으로 인해 잘못된 테스트로 글을 적은 점 사과하며 아래글도 함께 보시면 이해에 도움이 되겠습니다.
    • Adobe Alchemy 수행속도 테스트와 깊이 이해하기

    + Recent posts