출처: http://ubuntuforums.org/showthread.php?t=1561822

"
VMware can't find kernel header  " problem...


  
To install VMware Tools on a Ubuntu 10.04 Guest, from a Windows 7 Host (running VMware server 2.0.2) this documentation article (https://help.ubuntu.com/community/VMware/Tools) instructs you to use the following commands:
Code:
sudo apt-get install build-essential linux-headers-`uname -r` psmisc
then later
Code:
sudo ./vmware-install.pl
However, like others have posted before, this results in compilation errors:


Quote:
you can install the driver by running vmware-config-tools.pl again after making sure that gcc, binutils, make and the kernel sources for your running kernel are installed on your machine.
a) are there instructions available that will allow me to fulfill these requirements?
b) can said instructions be added to the documentation?

There are numerous threads regarding similar issues with VMware Tools. But many of them are unclearly stated, I hope that I have avoided that pitfall.
신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

Install VMware tools in Ubuntu server 10.04  (2) 2011.10.26
printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
Posted by 나마스떼

댓글을 달아 주세요

  1. comment maigrir 2011.12.15 18:00 신고  댓글주소  수정/삭제  댓글쓰기

    웹사이트 나는 후회 당신이 게시 할 쓴거야 더 보통 !

  2. Marlin 2011.12.19 21:10 신고  댓글주소  수정/삭제  댓글쓰기

    블로그 !처럼 우리는 이것이 정말 내 중 하나입니다 입니다 친절 에 읽기 !


As a kernel developer you'll probably find yourself treating the 'printk' function as a drop-in replacement for the 'printf' function provided by any useful C library such as uclibc or glibc - After all, it's usage is virtually the same. It was for this reason that I found my self naively surprised when reading the source for the kernel's implementation - I was surprised because it offers many more features than the typical C libraries' implementation. As I was unable to find any useful documentation on this - I thought I'd provide a brief overview.

Let's start with the typical '%p' type format specifier - we usually use it for printing the address of a pointer. However if you take a peek at the 'pointer' function in lib/vsprintf.c you'll notice that you can further specify the pointer type to print additional information. We'll look at some examples.

printk("%pf %pF\n", ptr, ptr) will print:
module_start module_start+0x0/0x62 [hello] 
So where ptr is a function pointer, the %pF and %pf format specifiers will print the symbolic name of the function with or without an offset. In order to make use of this you need to ensure your kernel is compiled with support for CONFIG_KALLSYMS - This adds a symbol table to the kernel.

How about this one:

printk("%pM %pm\n", mac, mac) will print:
2c:00:1d:00:1b:00 2c001d001b00 

So where mac refers to a MAC address, the %pM and %pm format specifiers will nicely print the MAC address with or without colons between bytes.

And finally:

printk("%pI4 %pi64\n", ip, ip) will print:
127.0.0.1 127.000.000.001

So where ip refers to an IP address, the %pI and %pi format specifiers will nicely print the IP address. The 4 suffix specifies the address is an IPv4 address - the 6 suffix for IPv6 address could also be used instead. In the case of IPv4 addresses the difference between an upper and lower case 'I' determines if leading zeros should be used (only in the most recent of kernels). In the case of IPv6 addresses the capitalization determines if colons are used or not.

So if you find yourself writing a network driver, debugging something with function pointers or wondering why stack traces don't contain symbols then these format specifiers may come in useful. For more information, and the full extent of the extended format specifiers (there are more), the best place to look is the code. Happy Coding.

신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

Install VMware tools in Ubuntu server 10.04  (2) 2011.10.26
printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
Posted by 나마스떼

댓글을 달아 주세요

1. cp MY-MIB net-snmp/local
2. 환경변수 설정  - export MIBS="./MY-MIB"
3. mib2c -c mib2c.old-api.conf module_name
4. bug 수정 및 compile
신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

Install VMware tools in Ubuntu server 10.04  (2) 2011.10.26
printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
Posted by 나마스떼

댓글을 달아 주세요

이 글은 나마스떼님의 2008년 1월 28일의 미투데이 내용입니다.

신고
Posted by 나마스떼

댓글을 달아 주세요

리눅스에서 amp 환경에서 작업을 하다가 부득이하게 윈도우즈로 포팅해야 하는 상황이 생겼다.
요즘 윈도우버전의 amp도 있다고는 들었지만 이렇게 간단하게 설치가 될 줄이야....

설치판 하나로 amp 뿐만아니라 phpmyadmin, tomcat 등 다양한 것들이 깔린다.

다운 받는 곳: http://www.apachefriends.org/en/xampp-windows.html

설치 후 확인해야 할 것
1) my.ini, php.ini에서 timezone을 Asia/Tokyo -> Asia/Seoul로 바꿀 것
2) php.ini에서 register_globals를 Off->On으로 바꿀 것
   : 이것 때문에 php에서 변수 값이 안넘어가서 삽질을 1시간이나 했다는.. ㅜㅜ
3) web의 Document_root는 c:\axmpp\htdocs 임.

그외 리눅스 소스의 윈도우 포팅 시 문제점.
윈도우 버전의 mysql library가 winsock2를 쓰면서 생기는 문제.
mysql library를 mysqlclient.lib를 사용하지 말고 libmysql.dll, libmysql.lib를 사용. 동적라이브러리 사용해서 해결.
그리고, 리눅스에서는 DB에 한글 입력 시 set names utf8 query를 날려야 하지만
윈도우는 set names euckr를 날려야 제대로 insert가 된다.

암튼 포팅하는데만 하루가 더 걸렸따..
안하던 xml에 웹까지 하려니.
힘들다 힘들어..

그래도 아직까지는 재미있네..^^


2. 프로젝트별 서브디렉토리 설정 (아파치 웹서버 설정)

XAMPP 를 설치한 이후 웹브라우저에서 http://localhost 라고 입력하면 XAMPP 가 설치된 디렉토리의 하위 디렉토리인 htdocs 디렉토리 아래의 index 파일이 실행된다.
이것은 httpd.conf 파일(XAMPP\apache\conf)에서

DocumentRoot "C:/XAMPP/htdocs"

와 같이 설정되어 있기 때문이다.

그런데 거의 대부분의 개발자들은 위 디렉토리를 로컬에서 개발하는 프로젝트의 루트디렉토리로 사용하지 않는다.
예를 들어서 D:\MyWebProject 라는 디렉토리를 웹프로젝트의 개발 루트 디렉토리로 사용한다라고 가정한다면 그 하위로 도메인별 루트폴더를 만들어서 프로젝트를 관리한다.

D:\MyWebProject\iwoohaha.com ==> iwoohaha.com
D:\MyWebProject\daesungmicro.com ==> daesungmicro.com
D:\MyWebProject\dkter.com ==> dkter.com

이런 경우 로컬에서 테스트하기 위한 웹주소를 다음과 설정해야 할 필요가 있다.

iwoohaha.com ==> http://localhost/iwoohaha
daesungmicro.com ==> http://localhost/daesungmicro
dkter.com ==> http://localhost/dkter

위와 같이 설정하기 위해서는 httpd.conf 파일에 Alias 를 추가설정하면 된다.

Alias    /iwoohaha          "D:/MyWebProject/iwoohaha.com/"
Alias    /daesungmicro    "D:/MyWebProject/daesungmicro.com/"
Alias    /dkter                  "D:/MyWebProject/dkter.com/"

Alias 이름에 /iwoohaha/ 처럼 마지막에 슬래시를 붙이는 것과 떼는 것의 차이는 직접 알아보는 것이 좋을 듯 하다.

신고

'빵꾸똥꾸 개발자 > Web' 카테고리의 다른 글

xampp  (0) 2010.03.24
Xerces-C++ install  (0) 2010.02.16
XML Data binding in C++  (0) 2010.02.16
Posted by 나마스떼

댓글을 달아 주세요

출처: http://jihune.com/tc/zemyblue/tag/298


visual studio 2005부터 MFC나 CRT등의 dll 라이브러리를 사용할 때 각각의 버젼을 달리 사용할 수 있도록 winSxS(side-by-side) 기능을 도입해서 배포할 때 주의를 기울이지 않으면 "Win32 error On14001"의 "응용 프로그램 구성이 올바르지 않기 때문에 이 응용 프로그램을 시작하지 못했습니다"라는 에러를 볼 수 있습니다.

이 는 dll이나 exe 파일을 컴파일 할 때 링크로 참조하는 dll 파일들을 버젼과 경로등을 manifest라는 파일로 관리하고 이를 dll, exe 파일에 포함시켜서 찾으려고 하는데 찾지 못하기 때문에 나오는 에러입니다.

제가 이 에러를 본것은 콘솔창에서 실행되는 프로그램을 개발했기 때문에 VC80.CRT라는 디렉토리에 있는 라이브러리를 찾는데. 이를 visual studio 2008이 설치되지 않은 다름 컴에서는 찾지 못하기 때문에 발생을 했었습니다.
컴파일을 할 때 object들이 생성되는 디렉토리에 보면은 <프로그램명>.<확장자(exe또는 dll)>.intermediate(또는 embed).manifest 파일을 보실 수 있습니다. 이를 열어보면 다음과 같습니다.

<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
    <security>
      <requestedPrivileges>
        <requestedExecutionLevel level='asInvoker' uiAccess='false' />
      </requestedPrivileges>
    </security>
  </trustInfo>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity type='win32' name='Microsoft.VC90.CRT' version='9.0.21022.8' processorArchitecture='x86' publicKeyToken='1fc8b3b9a1e18e3b' />
    </dependentAssembly>
  </dependency>
</assembly>


(위 파일을 Release로 컴파일을 한후에 생성된 manifest 파일입니다.)
여기서 중요한 것은 굵은 글씨체로 표시한 부분인데 이 부분이 참조할 dll 파일들의 경로와 버젼등의 정보를 표시한 것입니다. 이것을 찾아야 하는데 이게 없기 때문에 프로그램이 실행되지 않고 에러가 나오는 것입니다.

여기서 Microsoft.VC90.CRT라는 디렉토리를 찾게 되는데 찾는 디렉토리의 순서가 다음과 같기 때문에 다음의 어떠한 경우라도 속하면 프로그램은 이상없이 실행될 수 있습니다.

  1. WinSxS하위의 Side-by-side가 속한 디렉토리, 그러니까. 위와 같은 경우에는 "C:/Windows/WinSxS/x86_microsoft.vc90.crt_1fc8b3b9a1e18e3b_9.0.21022.8_none_bcb86ed6ac711f91" 를 찾습니다.
  2. 어플이 있는 디렉토리에서 해당 DLL 파일, 위와 같은 경우에는 Microsoft.VC90.CRT로 구성된 msvcm90.dll, msvcp90.dll, msvcr90.dll 이 어플과 같이 있으면 됩니다.
  3. 어플이 있는 디렉토리에서 <assemblyname>.manifest 파일
  4. 어플이 있는 디렉토리에서 <assemblyname>디렉토리 하위에 해당 DLL 파일
  5. 어플이 있는 디렉토리에서 <assemblyname>/<assemblyname>.manifest 파일
그 러므로 위와 같이 해당 파일이 dll 파일이 적절히 있다면 문제없이 실행될 것입니다. 여기서 assemblyname은 위와 같은 경우에는 Microsoft.VC90.CRT가 해당됩니다.

첫번째에 바로 검색될 수 있게 하기위해서는 참조하는 dll들을 자동으로 설치해주는 재배포 파일을 설치하면 됩니다. 재배포파일은 http://www.microsoft.com/downloads/deta ··· 62a191ee 에서 다운로드할 수 있습니다.

그런데 만약 Debug로 컴파일이 되었다면 Microsoft.VC90.DebugCRT가 더 추가되어 있을 것입니다.
제도 이것때문에 삽질을 했는데 분명 Release로 컴파일을 했는데. 컴파일 옵션에 _DEBUG가 들어가 있어서 일부가 Debug로 컴파일 되어서 manifest에서 DebugCRT를 요구했엇는데 VS 2005에서는 재배포 파일에 DebugCRT의 dll이 있는데 VS 2008 용 재배포 파일에는 Debug용은 CRT이든 MFC이든 모두 없으므로 아무리 설치를 했다고 해도 실행이 안되는 건 마찬가지 일 것입니다.

그 러므로 이를 해결하기 위해서는 Microsoft.VC90.DebugCRT를 해당 어플이 있는 디렉토리에 복사하던가 컴파일 시 Debug 정보가 없도록 해야 합니다.

Microsoft.VC90.DebugCRT는 <VS2008설치디렉토리>/VC/redist/Debug_NonRedist/x86/에 있습니다.
그리고 컴파일시에 Debug 정보가 있는지의 여부는 object 파일들이 생기는 중간 디렉토리 하위에 있는 manifest에 DebugXXX의 정보가 없으면 됩니다. 있다면 다시 한번 확인해 보세요.


이러한 해결법은 2005에서도 동일하게 적용됩니다. 재배포로 포함되는 dll들은 ATL, CRT, MFC, MFCLOC, OPENMP가 있습니다. 참조하세요.

일주일을 삽질한 결과입니다. ㅜㅜ

제가 문제를 해결할 때 참조한 사이트들입니다.

마이크로소프트에서 설명한 페이지
http://msdn.microsoft.com/ko-kr/library/ms235512.aspx
http://msdn.microsoft.com/ko-kr/library/ms235317.aspx 이는 설치형으로 프로그램을 배포해서 해결하는 방법입니다.

Side-by-side Assembly에 대해서 가장 잘 설명한 페이지
http://www.serious-code.net/moin.cgi/re ··· elibrary

저 하고 동일한 고민을 해결하는 과정이 그대로 적혀있군요. 전 이걸보고 힌트를 얻어서 해결할 수 있었습니다. ^^
http://www.panda3d.org/phpbb2/viewtopic ··· f64c61b5

신고

'빵꾸똥꾸 개발자 > Windows' 카테고리의 다른 글

win32 vc2005/2008 배포시 문제 해결  (0) 2010.03.24
[win32] libiconv 포팅하기  (0) 2010.03.17
Posted by 나마스떼

댓글을 달아 주세요

출처: http://www.dduri.net/blog/entry/ctags

1. ctags 란 ?
   = >  ctags는 프로그래밍 소스 코드의 태그 (전역변수 선언, 함수 정의, 메크로 정의)들의
          데이터 베이스(tags파일)을 생성하는 명령어입니다.
          커널 소스 분석등 작업에서 탁월한 성능을 발휘합니다

2. ctags 버전 확인하기
    = > (쉘에서)  $ctags --version 이라고 입력한다 설치 돼어 있는경우 버전 정보가 나옵니다
    cannat commond find  => 깔려 있지 않을시 에러 출력
    ( 대부분 기본리눅스에서 디폴트로 깔려 있지 않을것이다 처음 설치시 전체 설치 또는..
      선택 설치로 ctags를 설치 한경우라면 몰라도 디폴트로는 거의 안깔려 있습니다.
      특히 ubuntu 의 경우 원래 데스크탑용으로 개발 돼고 있어서.. 개발 툴이 하나도 안깔려 있기
      때문에 별또 설치를 필요로 합니다 )

3. ctags 설치하기
    => ubuntu 의 경우 레드헷 이나 페도라 등 다른 리눅스에 비해 비교적 쉽게 설치할수 있습니다
        레드헷일 경우 rpm 버전을 따로 다운 받아 설치 해야 하는 방면 데비안 계열 명령어
        apt-get으로 간편하게 설치가 가능합니다

    ubuntu 설치 하기
       (쉘에서) $apt-get install  ctags  (자동으로 최신 버전으로 설치 됩니다 )

    redhat 설치하기 http://sourceforge.net/projects/ctags (rpm 버전을 다운 받은후)
        (쉘에서) $rpm -ivf 다운받은 rpm 파일명 (으로 설치 하실수 있습니다)

    설치 완료 후 2번 과정 버전을 확인 하면 버전 정보가 재대로 나오면 재대로 설치가 되었습니다.
    레드헷 일 경우 lib.so 에러가 발생할수 있는데 버전이 안맞는 것을 깔면.. 설치가 재대로
    돼지 않는 문제점이 발생합니다 위 링크에서 최신버전 5.6.1 의 경우 페도라 5 용 이므로
    레드헷일 경우 5.0 버전 이나 찾아보시고 하위 지원 돼는 버전을 설치 해야 합니다..
    확인 결과 5.0.1 은 재대로 설치가 가능하더라고요..

4. tags 파일 만들기
    = > 우선 커널이 있는 폴더로 이동 합니다
           $cd /usr/src/linux/  <== ( 전 linux로 심볼릭 링크가 돼어 있습니다 안돼어 있다면
           심볼릭 링크를 만드셔도 돼고 직접 경로를 다 입력 하셔도 상관없습니다)
           심볼릭 링크 만들기 -> ln -s  /usr/src/커널폴더명 linux
           커널 폴더로 이동했으면 ctags -R 을 입력하여 tags 파일을 생성합니다
           시간이 좀 걸리는데 ls로  tags 파일이 생성 된걸 확인 합니다

          $cd /usr/include 폴더로 이동 합니다
           마찬가지로 ctags -R 명령으로 include 폴더도 tags 파일을 생성 합니다
           정상적으로 파일이 생성 되었다면 다음 단계로 넘어갑니다

5. ctags 설정 하기
    = > 설치 가 완료 되고 tags파일이 생성 되었다면 작업이 거의 끝난거나 마찬 가지 입니다.
           매번 vi 에서 ex모드 에서 입력하는거도 한계가 있으므로 .vimrc 파일에
           tags 를 설정 해두는게 편합니다
           vimrc 파일에 다음 라인을 입력 한후 저장합니다
           set tags=./tags,/usr/src/linux/tags,/usr/include/tags
           (linux 의 경우 심볼릭 링크 한경우)  직접 폴더를 입력 하신분은 경롱에 맞게 설정 합니다


사용하기          
=====================================================
여기 까지 했다면 설치 및 설정은 완료 되었습니다..

이제 사용 하는거만 남았는데
복잡하게 책에는 여러 옵션이 많지만 보통 잘안쓰는 옵션들은.. 거의 쓸일이 없고..
자주 쓰는 것만 다루겠습니다.

ex 모드 -> vi 에서 : 을 눌러서 명령을 입력 하는 모드를 말합니다
ex 모드에서 :tj 함수명 이나 구조체명 (왜 tj 인가 ?  tags jump 약어)
(찾고자 하는 함수명이나 구조체 이름등을 입력 하면 관력 이름 함수나 구조제..정보가 나타 납니다 )
보통 한두가개 아닌경우 스페이스바를 누르면 목록이 더나오며 d 를 누를 경우 한페이지씩..
보여 줍니다 나갈때는 q로 나갈수 있습니다 그럼 <CR> 이 나오는데 여기서 찾은 함수나 구조체
번호를 입력 하면 자동으로 점프합니다

다른 방법으로 가는 방법은 커널 소스를 vi열어서 분석하다가 함수 원형이나 구조체 이름에서
ctrl + ] 를 누르면 자동으로 태그를 찾아 갑니다
이전으로 다시 돌아 올때는 ctrl + t 를 사용 해서 돌아 올수 있습니다

ex모드 : sts 함수명 , 구조체명
위에서 설명한 tj와 비슷 하지만 한가지 다른점이 수평창분활을 해서 결과를 보여 줍니다

이외 명령이 더 있지만 실제 이거만 알아도 충분 합니다 나머지 이전으로 돌아가기 이런건..
거의 실제 사용 되지도 않습니다 위에 설명한 4가지 방법이 주로 쓰는 방법입니다.

[tip] 헤더 파일 바로 읽어 오기

#include <linux/kernel.h> <- 헤더파일 이름에 커서를 위치 한후

Ctrl + wf 를 누르면 창이 수평 분할되어 헤더파일이 열립니다

====================================================
cscope 를 이용한 2%로 채우기
    ctags만으로도 커널소스와 소규모 프로젝트롤 분석하는데 부족함은 없지만..
    2%로 부족한게 있다 ctags만으로는 지역변수나 전역변수가 사용된곳 은 찾기가 힘들다
    이때 cscope 사용하면 됩니다

cscope 설치 하기
    ubuntu = > $apt-get install cscope 로 간단히 설치 할수 있다 (데비안 계열의 강점)
    redhat
    (다운 로드)
    wget
http://belnet.dl.sourceforge.net/sourceforge/cscope/cscope-15.3-1.i386.rpm
    설치 하기
    $rpm -ivf cscope-15.3-1.i386.rpm

cscope 설정 하기
   cscope 설정은 좀 손이 많이 갑니다 (ctags에 비해...)
    우선 mkcscope.sh 파일을 만들어야 합니다
   ============ mkcscope.sh 파일 내용 ================
    #!/bin/sh
    rm -rf cscope.files cscope.files

    find . \ ( -name '*.c' -o -name '*.cpp' -o -name '*.cc' -o -name '*.h'
    -o -name '*.s' -o -name '*.S' \ ) - print > cscope.files

    cscope -i cscope.files
    ============================================
    파일 생성 후 파일 퍼미션 설정
    $chmod 755 mkcscope.sh
    $mv mkcscope.sh /usr/bin
    디렉토리 이동
    $cd /usr/src/linux (심볼릭 링크 아닐시 전체 경로)
    mkcscope.sh 실행  하면 빌드 돼면서 데이터가 만들어 집니다
    빌드 종료시 값을 입력 하는게 나오는데 ctrl + d를 눌러서 종료 합니다.
   
    이후 .vimrc 파일에 다음 내용을 추가 합니다
    =============================================
    set csprg=/usr/bin/cscope
    set csto=0(숫자 0)
    set cst
    set nocsverb

    if filereadable("./cscope.out")
       cs add cscope.out
    else
       cs add /usr/src/linux/cscope.out
    endif
    set csverb
   ==============================================
   이제  설정은 끝이 났습니다

   사용하기 ( cscope 의 명령 형식 )
    :cs find {질의종류} {심벌}
    ex) cs find s start_kernel

   cscope 의 질의 종류
    0 or s  - > Find this C symbol
    1 or g  - > Find this definition
    2 or d  - > Find functions called by this function
    3 or c  - > Find functions calling this function
    4 or t  - > Find assignments to
    6 or e  - > Find this egrep pattern
    7 or f   - > Find this File
    8 or i   - > Find files #including this file
신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
kdevelop로 리눅스에서 C 코딩 하기  (0) 2007.10.27
Posted by 나마스떼

댓글을 달아 주세요

출처: http://jaic.info/it_chie/81327/page/3
phpmyadmin사용 시 문자셋이 UTF-8일 경우
한글이나 일본어 등 유니코드가 깨져보일 경우

phpmyadmin 초기설정단계에서 MySQL 문자셋을 UTF-8 Unicode (utf8)로 지정해준다음
테이블안 필드의 collation 또한 UTF-8 Unicode로 설정해줘야 한다.

만약 이경우 한국어가 깨져보인다면
웹브라우저의 인코딩 혹은 phpmyadmin의 언어선택을 한국어로 변경해주면 된다.

또 php에서 DB연결할때에도 mysql_query('set names utf8');로 설정해줘야한다.
신고

'빵꾸똥꾸 개발자 > Database' 카테고리의 다른 글

phpmyadmin사용시 UTF-8일 경우  (0) 2010.03.19
Posted by 나마스떼

댓글을 달아 주세요


요즘 작업을 우분투 <-> 리눅스 왔다리 갔다리 하면서 하고 있다.
지금 내 작업 PC에는  ubuntu desktop 9.10을 설치하여 사용하고 있는데.
공용 서버로 오늘 우분투 서버를 깔아봤다.

석사이후론 애들만 시켜버릇해서. 리눅스를 깔아본게 몇년만인지.ㅋ
암튼 우분투 데스크탑만 깔다가 올만에 서버깔고 콘솔뜨니 당황스럽더라.ㅋ

암튼, Ubuntu 서버를 깔면 콘솔이 뜬다.
이럴경우 우분투 데스크탑을 쓰는 방법은 아래와 같다..

$sudo apt-get update
$sudo apt-get dist-update

$sudo apt-get install ubuntu-desktop

$sudo /etc/init.d/gdm start

The above command will install GNOME desktop

If you wan to install a graphical desktop manager without some of the desktop addons like Evolution and OpenOffice, but continue to use the server flavor kernel use the following command

$sudo aptitude install --no-install-recommends ubuntu-desktop

If you want to install light weight desktop install xfce using the following command

$sudo apt-get install xubuntu-desktop

If you want to install KDE desktop use the following command

$sudo apt-get install kubuntu-desktop


신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
kdevelop로 리눅스에서 C 코딩 하기  (0) 2007.10.27
Posted by 나마스떼

댓글을 달아 주세요

ibiconv 라이브러리는 GNU 프로젝트의 하나로 인코딩간의 변환을 지원한다. linux 계열의 소프트웨어에서 문자열 인코딩 변환은 전부 이 라이브러리로 이루어질 정도로, 아주 중요한 포지션을 담당하는 라이브러리이다. 예를 들어 php의 iconv() 함수는 최종적으로 이 라이브러리를 사용하게 된다.

Windows의 경우 인코딩 간 변환은 WideCharToMultiByte() 나 MultiByteToWideChar() 함수를 통해 할 수 있기 때문에 대부분의 경우 libiconv가 필요 없다. 하지만 Windows Mobile 환경에서는 OS 언어에 대한 문자열 변환만을 지원하기 때문에, libiconv와 같은 인코딩 변환 라이브러리가 필요해진다.

따라서 이 글에서는 libiconv를 Visual Studio에서 컴파일하는 방법을 살펴보기로 한다.

linux 쪽의 프로젝트를 포팅하는 경우에는 Visual Studio 프로젝트 파일을 어떻게 구성할지가 제일 난감하다. libiconv 의 경우도 어디서부터 손을 대어야 할지가 굉장히 난감했었는데, 소스 파일을 들여다 보면, 다행히도 대부분이 헤더 파일이고 c 파일은 몇 개 없다는 사실을 발견할 수 있다.

두번째로 다행인 점은 다른 오픈 소스 프로젝트와는 다르게, libiconv의 경우에는 몇 버전 전까지만 해도 Visual Studio 에서 native compile을 지원했었다. 하지만 아쉽게도, 이제는 mingw 프로젝트 때문에 win32용 응용 프로그램을 gcc로 컴파일할 수 있게 되어 더 이상 지원하지 않는다고 한다. 그러나 일단 VS용으로 터닦이 공사가 끝난 터라 큰 문제 없이 포팅 가능하다.

기본적으로 다음과 같은 수순으로 작업하면 된다. libiconv 1.13.1을 사용하였다.

  1. visual studio 에서 dll 프로젝트를 구성한다.
  2. 컴파일해야 하는 소스 파일은 3개.  lib/iconv.c  lib/relocatable.c libcharset/lib/localcharset.c   뿐이다. 컴파일 할 때 발생하는 include path 관련 에러를 모두 잡아준다.
  3. libcharset/include/libcharset.h.build.in 과 include/iconv.h.build.in 의 확장자를 수정하여 h 파일로 바꾼다. build.in을 사용하는 이유는 dll export 키워드를 넣어주기 위함이다.
  4. localcharset 에서 LIBDIR 관련 에러가 나는데, 주석으로 막아버린다.
  5. @HAVE_VISIBILITY@ 나 @DLL_VARIABLE@ @ICONV_CONST@ 따위가 있는데, 이건 autoconf 에서 자동으로 이름이 바뀌는 변수들로, 각각 없애고, 없애고, const로 바꿔주면 된다.

여기까지가 win32 용의 dll로 컴파일 하는 방법이다. 좀 더 자세한 변경 사항을 보고 싶다면, http://wiki.michgan.net/moin.cgi/iconv/Windows 을 본다.

Windows Mobile 용의 dll로 컴파일하려면 위의 작업에서 추가적으로 errno 변수 관련 작업을 해줘야 한다. Windows Mobile 에는 errno 변수가 없기 때문이다. 그냥 dll 내에서 int errno; 라고 선언하고 몇몇 매크로를 define 해주는 것으로 컴파일이 가능하다.
물론 errno 값을 dll 외부에서 확인하려면 조회할 수 있는 함수와 thread local storage에 저장이 되도록 구현해야겠지만, 에러 유무만 알면 됐지 뭐. diff 파일이 필요하다면 http://wiki.michgan.net/moin.cgi/iconv/WindowsMobile 을 본다.

이상으로 libiconv 프로젝트를 win32 용의 dll로 컴파일 하는 방법을 살펴 보았다.
참고로 libiconv는 LGPL 라이센스이다.

출처 : http://blog.michgan.net/49

신고

'빵꾸똥꾸 개발자 > Windows' 카테고리의 다른 글

win32 vc2005/2008 배포시 문제 해결  (0) 2010.03.24
[win32] libiconv 포팅하기  (0) 2010.03.17
Posted by 나마스떼

댓글을 달아 주세요

출처: http://tubbies.thoth.kr/?mid=blog&category=365486&document_srl=365554

1. 한글 설정


먼저 본인은 EUC-KR 문자셋을 선호하기 때문에 우분투의 기본인 UTF-8을 버리고
EUC-KR을 선택하는 것 부터 시작한다...윈도우와 어느정도 호환성이나 나비와 같은 입력기 때문에

1) 언어 패키지 설치
먼저 여러 Langauge가 깔리는걸 싫어해서 영어로 깔린 상태로 가정하면 한글팩이 안깔려 있으므로
$ sudo apt-get install language-pack-ko

2) 로케일 생성
한글 팩이 깔려 있다고 해도 한글 로케일이 설치가 되어 있지 않다면 한글  입력을 할 수 없으므로 로케일을 생성한다

$ sudo locale-gen ko_KR.EUC-KR

우분투의 아버지 데비안 경우에는

dpkg-reconfigure locales에서 나오는 목록에서

EUC-KR을 선택하면 된다

3) 나비 설치

한글 입력기로 필자는 nabi라는 프로그램을 선호하므로 이 프로그램을 설정 전에 깔아보면

$ sudo apt-get install nabi

그리고 이후 시작 프로그램으로 등록하도록 설정하면

설정 메뉴를 찾아 Session을 실행해서 Startup Program에 nabi를 등록한다

4) nabi 및 입력 인코딩 설정

gnome을 띄운 상태에서 사용자 계정으로
$ unset LC_ALL

$ export LANG=ko_KR.eucKR 

이렇게 해서 환경변수에 EUC-KR을 올린 후 설정을 하기 위해 나비를 실행시킨다

$ nabi &

이 후 나비가 GNOME의 기본 입력기가 될 수 있도록 해주면

$ export XMODIFIERS="@im=nabi" 

$ export GTK_IM_MODULE=xim

$ im-switch -c 선택 후 nabi 선택
(만일 im-switch가 없다면 $ sudo apt-get install im-switch 를 통해 설치하자)

재부팅 하고 즐겁게 사용하면 된다
신고

'빵꾸똥꾸 개발자 > Linux' 카테고리의 다른 글

printk  (0) 2011.05.13
mib2c 사용법  (0) 2011.05.02
ctags & cscope 설치 및 사용하기  (0) 2010.03.19
How to install GUI in Ubuntu 9.10 (Karmic) Server  (0) 2010.03.17
ubuntu 한글설정  (0) 2010.03.02
kdevelop로 리눅스에서 C 코딩 하기  (0) 2007.10.27
Posted by 나마스떼

댓글을 달아 주세요

Windows
 

This section contains installation instructions for the Windows platform.

Source distribution
 

The Xerces-C++ source is available in the source distribution: xerces-c-3.1.0.zip.

Install the Xerces-C++ source distribution by using unzip on the xerces-c-3.1.0.zip archive in the Windows environment. You can use WinZip, or any other UnZip utility:

unzip xerces-c-3.1.0.zip

This creates the 'xerces-c-3.1.0' sub-directory containing the Xerces-C++ source distribution.

If you need to build the Xerces-C++ source after installation, please follow the Build Instructions.


Binary distribution
 

Install the Xerces-C++ binary distribution by using unzip on the xerces-c-3.1.0-{arch}-windows-{compiler}.zip archive in the Windows environment. Here {arch} denotes the CPU architecture and {compiler} denotes the C++ compiler of your choice. You can use WinZip, or any other UnZip utility. For example:

unzip xerces-c-3.1.0-x86-windows-vc-8.0.zip

This creates a 'xerces-c-3.1.0-x86-windows-vc-8.0' sub-directory containing the Xerces-C++ binary distribution.

You need to add the 'xerces-c-3.1.0-{arch}-windows-{compiler}\bin' directory to your path. To do this go to the start menu, click the settings menu and select control panel. When the control panel opens, double click on System and select the 'Environment' tab. Locate the PATH variable under system variables and add <full-path-to-xerces-c-3.1.0-{arch}-windows-{compiler}>\bin to the PATH variable.

Additionally, if you don't have the corresponding version of Microsoft Visual C++ installed, you may need to download and install the C/C++ runtime libraries from the Microsoft website. For example, for Visual Studio 2008 (9.0) the package is called "Microsoft Visual C++ 2008 Redistributable Package".

The binary distribution contains the pre-built parser libraries and sample executables. Please refer to the Samples for how to run the samples.

신고

'빵꾸똥꾸 개발자 > Web' 카테고리의 다른 글

xampp  (0) 2010.03.24
Xerces-C++ install  (0) 2010.02.16
XML Data binding in C++  (0) 2010.02.16
Posted by 나마스떼

댓글을 달아 주세요


출처) http://www.artima.com/cppsource/xml_data_binding.html

The C++ Source
An Introduction to XML Data Binding in C++
by Boris Kolpackov
May 4, 2007


Summary
XML processing has become a common task that many C++ application developers have to deal with. Using low-level XML access APIs such as DOM and SAX is tedious and error-prone, especially for large XML vocabularies. XML Data Binding is a new alternative which automates much of the task by presenting the information stored in XML as a statically-typed, vocabulary-specific object model. This article introduces XML Data Binding and shows how it can simplify XML processing in C++.

Introduction

A typical C++ application that has to manipulate the data stored in XML format uses one of the two common XML access APIs: Document Object Model (DOM) or Simple API for XML (SAX). DOM represents XML as a tree-like data structure which can be navigated and examined by the application. SAX is an event-driven XML processing API. The application registers its interest in certain events, such as start element tag, attribute, or text, which are then triggered during the parsing of an XML instance. While DOM has to read the whole document into memory before the application can examine the data, SAX delivers the data as parsing progresses.

Anyone who has had to handle a large XML vocabulary using DOM or SAX can attest that the task is hardly enjoyable. After all, both DOM and SAX are raw representations of the XML structure, operating in generic elements, attributes, and text. An application developer often has to write a substantial amount of bridging code that identifies and transforms pieces of information encoded in XML to a representation more suitable for consumption by the application logic. Consider, for example, a simple XML document that describes a person:

<person>
<name>John Doe</name>
<gender>male</gender>
<age>32</age>
</person>

If we wanted to make sure the person's age is greater than some predefined limit, with both DOM and SAX we would first have to find the age element and then parse the string representation of 32 to obtain the integer value that can be compared. Another significant drawback of generic APIs is string-based flow control. In the example above, when we search for the age element we pass the element name as a string. If we misspell it, we (or a user of our program) will most likely only discover this bug at runtime. String-based flow control also reduces code readability and maintainability. Furthermore, generic APIs lack type safety because all the information is represented as text. For example, we can compare the content of the gender element to an invalid value without any warning from the compiler:

DOMElement* gender = ...

if (gender->getTextContent () == "man")
{
...
}

In recent years a new approach to XML processing, called XML Data Binding, has emerged thanks to the progress in XML vocabulary specification languages (XML schemas). The main idea of XML Data Binding is to skip the raw representation of XML and instead deliver the data in an object-oriented representation that models a particular vocabulary. As a result, the application developer does not have to produce the bridging code anymore because the object model can be used directly in the implementation of the application logic. In the example above, instead of searching for the age element and then manually converting the text to an integer, we would simply call the age() function on the person object that already returns the age as an integer. The name XML Data Binding comes from the observation that the object representation is essentially bound to and becomes a proxy for the data stored in XML.

The vocabulary-specific object representation along with other support code such as parsing and serialization functions are generated by a data binding compiler from an XML schema. A schema is a formal specification of a vocabulary that defines the names of elements and attributes, their content, and the structural relationship between them. The majority of XML Data Binding tools use the W3C XML Schema specification language due to its object-oriented approach to the vocabulary description as well as its widespread use. The following fragment describes the XML vocabulary presented above using W3C XML Schema:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:simpleType name="gender_t">
<xs:restriction base="xs:string">
<xs:enumeration value="male"/>
<xs:enumeration value="female"/>
</xs:restriction>
</xs:simpleType>

<xs:complexType name="person_t">
<xs:sequence>
<xs:element name="name" type="xs:string"/>
<xs:element name="gender" type="gender_t"/>
<xs:element name="age" type="xs:short"/>
</xs:sequence>
</xs:complexType>

<xs:element name="person" type="person_t"/>

</xs:schema>

Even if you are not familiar with XML Schema, it should be fairly straightforward to figure out what is going on here. The gender_t type is an enumeration with the only valid string values being "male" and "female". The person_t type is defined as a sequence of the nested name, gender, and age elements. Note that the term sequence in XML Schema means that elements should appear in a particular order as opposed to appearing multiple times. Finally, the globally-defined person element prescribes the root element for our vocabulary. For an easily-approachable introduction to XML Schema refer to XML Schema Part 0: Primer.

Similar to the direct XML representation APIs, XML Data Binding supports both in-memory and event-driven programming models. In the next sections we will examine the complexity of performing common XML processing tasks using DOM and SAX compared to in-memory and event-driven XML Data Binding. The DOM and SAX examples in this article are based on Apache Xerces-C++ open-source XML parser with character conversions omitted to keep the code focused. The XML Data Binding examples are based on CodeSynthesis XSD open-source XML Schema to C++ data binding compiler.

In-Memory XML Data Binding

Based on an XML schema, a data binding compiler generates C++ classes that represent the given vocabulary as a tree-like in-memory data structure as well as parsing and serialization functions. The parsing functions are responsible for creating the in-memory representation from an XML instance while the serialization functions save the in-memory representation back to XML. For the schema presented in the introduction, a data binding compiler could generate the following code:

class gender_t
{
public:
enum value {male, female};

gender_t (value);
operator value () const;

private:
...
};

class person_t
{
public:
person_t (const string& name,
gender_t gender,
short age);

// name
//
string& name ();
const string& name () const;
void name (const string&);

// gender
//
gender_t& gender ();
gender_t gender () const;
void gender (gender_t);

// age
//
short& age ();
short age () const;
void age (short);

private:
...
};

std::auto_ptr<person_t> person (std::istream&);
void person (std::ostream&, const person_t&);

From studying the generated code and XML schema declarations, it becomes clear that the compiler maps schema type declarations to C++ classes, local elements to a set of accessors and modifiers, and global elements to a pair of parsing and serialization functions.

In the remainder of this section we will look into performing three common XML processing tasks using DOM and XML Data Binding. These tasks are accessing the data stored in XML, modifying the existing data, and creating a new data from scratch. Based on this exercise we will evaluate the advantages of using XML Data Binding over DOM.

The following code uses XML Data Binding to read in an XML file with a person record and print the person's name if the age is greater than 30. Error handling in this and subsequent code fragments is omitted for brevity.

ifstream ifs ("person.xml");
auto_ptr<person_t> p = person (ifs);

if (p->age () > 30)
cerr << p->name () << endl;

The example above is concise and to the point. Once the in-memory representation is created from the XML instance, the code has no traces of XML and looks natural, as if working with a hand-written object model. Note also that the XML data presented by the generated C++ classes is statically typed. The following code fragment performs the same task using DOM:

ifstream ifs ("person.xml");
DOMDocument* doc = read_dom (ifs);
DOMElement* p = doc->getDocumentElement ();

string name;
short age;

for (DOMNode* n = p->getFirstChild ();
n != 0;
n = n->getNextSibling ())
{
if (n->getNodeType () != DOMNode::ELEMENT_NODE)
continue;

string el_name = n->getNodeName ();
DOMNode* text = n->getFirstChild ();

if (el_name == "name")
{
name = text->getNodeValue ();
}
else if (el_name == "age")
{
istringstream iss (text->getNodeValue ());
iss >> age;
}
}

if (age > 30)
cerr << name << endl;

doc->release ();

The DOM version, besides being more complex, is also less safe because of the use of strings to identify elements. We could easily misspell one of them without any warning from the compiler. In the XML Data Binding version, misspelling a function name which identifies an element would lead to a compile error. Also note that the code in the DOM version is conceptually split into two parts. The first part extracts the data from the raw representation of XML provided by DOM. The second, much smaller part, implements the application logic and is essentially the same as the XML Data Binding version.

The following code snippet increments the age and changes the name using XML Data Binding:

ifstream ifs ("person.xml");
auto_ptr<person_t> p = person (ifs);
ifs.close ();

p->name ("John Smith");
p->age ()++;

ofstream ofs ("person.xml");
person (ofs, *p);

The DOM version that performs the same task is presented next.

ifstream ifs ("person.xml");
DOMDocument* doc = read_dom (ifs);
ifs.close ();
DOMElement* p = doc->getDocumentElement ();

for (DOMNode* n = p->getFirstChild ();
n != 0;
n = n->getNextSibling ())
{
if (n->getNodeType () != DOMNode::ELEMENT_NODE)
continue;

string el_name = n->getNodeName ();
DOMNode* text = n->getFirstChild ();

if (el_name == "name")
{
text->setNodeValue ("John Smith");
}
else if (el_name == "age")
{
istringstream iss (text->getNodeValue ());
iss >> age;
age++;
ostrinstream oss;
oss << age;
text->setNodeValue (oss.str ());
}
}

ofstream ofs ("person.xml");
write_dom (ofs, doc);
doc->release ();

Again the DOM version suffers from extra complexity compared to XML Data Binding. In this case the DOM navigation and data conversion code is intermixed with the application logic implementation which further reduces readability and maintainability.

The final task that we will consider consists of the creation of a new person record from scratch. The XML Data Binding version is presented below:

person_t p ("John Doe", gender_t::male, 32);

ofstream ofs ("person.xml");
person (ofs, p);

The equivalent DOM version is shown below. Note that a more realistic example would require extra conversions for the gender and age values which are hard-coded as strings in this example.

DOMDocument* doc = create_dom ("person");
DOMElement* p = doc->getDocumentElement ();

DOMElement* e = doc->createElement ("name");
DOMText* t = doc->createCreateTextNode ("John Doe");
e->appendChild (t);
p->appendChild (e);

e = doc->createElement ("gender");
t = doc->createCreateTextNode ("male");
e->appendChild (t);
p->appendChild (e);

e = doc->createElement ("age");
t = doc->createCreateTextNode ("32");
e->appendChild (t);
p->appendChild (e);

ofstream ofs ("person.xml");
write_dom (ofs, doc);
doc->release ();

The examples presented in this section show that processing XML with DOM brings in a large amount of accidental complexity that is associated with navigating and converting the data store in XML as presented by DOM to a format usable by the application. In contrast, the object model provided by XML Data Binding is directly usable in the application logic implementation. The following list summarizes the key advantages of the in-memory XML Data Binding over DOM:

  • Ease of use. The generated code hides all the complexity associated with parsing and serializing XML. This includes navigating the structure and converting between the text representation and data types suitable for manipulation by the application logic.
  • Natural representation. The object representation allows us to access the XML data using our domain vocabulary instead of generic elements, attributes, and text.
  • Concise code. With the object representation the application logic implementation is simpler and thus easier to read and understand.
  • Safety. The generated object model is statically typed and uses functions instead of strings to access the information. This helps catch programming errors at compile-time rather than at runtime.
  • Maintainability. Automatic code generation minimizes the effort needed to adapt the application to changes in the document structure. With static typing, the C++ compiler can pin-point the places in the client code that need to be changed.
  • Compatibility. Sequences of elements are represented in the object model as containers conforming to the standard C++ sequence requirements. This makes it possible to use standard C++ algorithms on the object representation and frees us from learning yet another container interface, as is the case with DOM.
  • Efficiency. If the application makes repetitive use of the data extracted from XML, then XML Data Binding is more efficient because the navigation is performed using function calls rather than string comparisons and the XML data is extracted only once. Furthermore, the runtime memory usage is reduced due to more efficient data storage (for instance, storing numeric data as integers instead of strings) as well as the static knowledge of cardinality constrains.

Event-Driven XML Data Binding

While the in-memory XML Data Binding and raw XML access APIs such as DOM are relatively easy to use and understand, there are situations where it is not possible or desirable to load the whole document into memory before doing any processing. Examples of such situations include handling XML documents that are too large to fit into memory and performing immediate processing as parts of the document become available (streaming). For applications that are unable to use the in-memory programming model there are even-driven XML Data Binding as well as raw XML access APIs such as SAX which allow to perform XML processing as parsing progresses.

Event-driven XML Data Binding consists of parser templates that represent the given vocabulary as a hierarchy of data availability events which are dispatched using the C++ virtual function mechanism. Compared to SAX, event-driven XML Data Binding shields us from the tasks of manual data extraction and event dispatching. For the schema presented in the introduction, a data binding compiler could generate the following parser templates:

template <typename gender_ret_t>
class gender_t: public xml_schema::parser<gender_ret_t>
{
public:
// Parser hooks.
//
virtual void pre ();
virtual void _characters (const string&);
virtual gender_ret_t post ();

private:
...
};

template <typename person_ret_t,
typename name_t,
typename gender_t,
typename age_t>
class person_t: public xml_schema::parser<person_ret_t>
{
public:
// Parser hooks.
//
virtual void pre ();
virtual void name (const name_t&) = 0;
virtual void gender (const gender_t&) = 0;
virtual void age (const age_t&) = 0;
virtual person_ret_t post ();

// Parser construction API.
//
void name_parser (xml_schema::parser<name_t>&);
void gender_parser (xml_schema::parser<gender_t>&);
void age_parser (xml_schema::parser<age_t>&);

private:
...
};

The generated code needs some explaining. Let us start with the person_t class template. The first five virtual member functions are called parser hooks. We override them in our implementation of the parser to do something useful.

The pre() function is an initialization hook. It is called when a new element of type person_t is about to be parsed. We can use this function to allocate a new instance of the resulting type or clear accumulators that are used to gather information during parsing. The default implementation of this parser hook does nothing.

The post() function is a finalization hook. It is called when parsing of the element is complete and the result of template type parameter person_ret_t should be returned. If person_ret_t is void then the default implementation of this parser hook also does nothing. Otherwise we must override this function in order to return the result value.

The name(), gender(), and age() functions are called when the corresponding elements have been parsed. Their arguments contain the data extracted from XML. The argument types are for us to decide and are paired with the return types of parser implementations that correspond to the types of name, gender, and age elements, respectively.

The last three functions are used to tell the person_t parser which parsers to use to parse the contents of name, gender, and age elements. We will see how to use them shortly.

The gender_t parser template has both pre() and post() hooks as well as the _characters() hook which delivers the raw text content of an element or attribute. The following code fragment shows how we can implement these parser templates to do the same task as in the previous section, namely print the person's name if the age is greater than 30:

enum gender {male, female};

class gender_impl: public gender_t<gender>
{
public:
virtual void pre ()
{
gender_.clear ();
}

virtual void _characters (const string& s)
{
gender_ += s;
}

virtual gender post ()
{
return gender_ == "male" ? male : female;
}

private:
string gender_;
};

class person_impl: public person_t <void, // return type
string, // name
gender, // gender
short> // age
{
public:
virtual void name (const string& n)
{
name_ = n;
}

virtual void gender (const ::gender& g)
{
gender_ = g;
}

virtual void age (const short& a)
{
age_ = a;
}

virtual void post ()
{
if (age_ > 30)
cerr << name_ << endl;
}

private:
string name_;
::gender gender_;
short age_;
};

Note that the argument type of the gender() function in person_impl matches the return type of the post() function from gender_impl. The following listing puts all the parsers together and parses the XML instance. Note that we use predefined parser implementations for built-in XML Schema types string and short. These come with the data binding compiler runtime.

// Construct the parser.
//
xml_schema::short_ short_p;
xml_schema::string string_p;

gender_impl gender_p;
person_impl person_p;

person_p.name_parser (string_p);
person_p.gender_parser (gender_p);
person_p.age_parser (short_p);

// Parse the XML instance. The second argument to the document's
// constructor is the document's root element name.
//
xml_schema::document<void> doc_p (person_p, "person");
doc_p.parse ("person.xml");

The following code fragment performs the same task using SAX:

enum gender {male, female};

class parser: public DefaultHandler
{
public:
virtual void startElement (const string& name)
{
text_.clear ();
}

virtual void characters (const string& s)
{
text_ += s;
}

virtual void endElement (const string& name)
{
if (name == "person")
{
if (age_ > 30)
cerr << name_ << endl;
}
else if (name == "name")
{
name_ = text_;
}
else if (name == "gender")
{
gender_ = text_ == "male" ? male : female;
}
else if (name == "age")
{
istringstream ss (text_);
ss >> age_;
}
}

private:
string name_;
gender gender_;
short age_;

string text_;
};

The SAX version is complicated by the additional code necessary to keep track of the element currently being parsed. The complexity will further increase for more realistic XML vocabularies because SAX events do not explicitly reflect the document structure. Instead, the application developer has to deduce the relationship between elements, attributes and text from the order of events being triggered. As with DOM, we also had to manually convert the text representation of age to the integer value and identify elements with strings which reduces the ability of the C++ compiler to detect errors. The following list summarizes the key advantages of the event-driven XML Data Binding over SAX:

  • Ease of use. The generated code hides all the complexity associated with recreating the document structure, maintaining the dispatch state, and converting the data from the text representation to data types suitable for manipulation by the application logic. Parser templates also provide a convenient mechanism for building custom in-memory representations.
  • Natural representation. The generated parser templates implement parser hooks as virtual functions with names corresponding to elements and attributes in XML. As a result, we process the XML data using our domain vocabulary instead of generic elements, attributes, and text.
  • Concise code. With separate parser template for each XML Schema type, the application logic implementation is simpler and thus easier to read and understand.
  • Safety. The XML data is delivered to parser hooks as statically typed objects. The parser hooks themselves are virtual functions. This helps catch programming errors at compile-time rather than at runtime.
  • Maintainability. Automatic code generation minimizes the effort needed to adapt the application to changes in the document structure. With static typing, the C++ compiler can pin-point the places in the client code that need to be changed.

Conclusions

Generic APIs such as DOM and SAX do not preserve the semantics of XML vocabularies and thus are disconnected from the problem domain. There are applications where DOM and SAX are more suitable than the domain-specific XML Data Binding approaches. Examples of such application include XML databases and editors where XML vocabularies are not known a priori. There are, however, large classes of applications that operate on a predefined XML vocabulary and are more concerned with the data stored in an XML-based format than with the XML syntax or structure. For such applications XML Data Binding can be an easier, safer and more enjoyable way to handle XML.

Share Your Opinion

Discuss this article in the Articles Forum topic, An Introduction to XML Data Binding in C++.

Resources

The XML Data Binding examples in this article are based on CodeSynthesis XSD open-source XML Schema to C++ data binding compiler, which is available at:
http://www.codesynthesis.com/products/xsd/

XML Schema Part 0: Primer, an easily approachable introduction to XML Schema, is at:
http://www.w3.org/TR/xmlschema-0/

The DOM and SAX examples in this article are based on the Apache Xerces-C++ open-source XML parser, which is available at:
http://xml.apache.org/xerces-c/

About the Author

Boris Kolpackov is currently a software engineer at Code Synthesis working on XML Data Binding tools for C++. His interests include compiler design, code generation, source-to-source translation, distributed systems, and kitesurfing.


신고

'빵꾸똥꾸 개발자 > Web' 카테고리의 다른 글

xampp  (0) 2010.03.24
Xerces-C++ install  (0) 2010.02.16
XML Data binding in C++  (0) 2010.02.16
Posted by 나마스떼

댓글을 달아 주세요

http://www.internetworkflow.com/downloads/ns2leach/

Installing NS-2.27 and LEACH extension on Fedora Core and Ubuntu

 

Step 0: Prepare neccesary files for installation

  1. NS-2.27 package: ns-allinone-2.27.tar.gz
  2. Patch for compiling NS-2.27 with GCC 4.1.x: ns-2.27-gcc410.patch
  3. MIT’s LEACH extension: mit.tar.gz
  4. LEACH’s Makefile patch: leach_makefile-2.27.patch

Step 1: Download NS-2.27, apply ns-2.27-gcc410.patch, and install it
Under your home directory (~):

 

  1. apt-get install build-essential autoconf automake libxmu-dev kernel-package libncurses5-dev fakeroot wget bzip2 (커널 설정!)

  2. wget http://www.internetworkflow.com/downloads/ns2leach/ns-allinone-2.27.tar.gz
  3. tar zxvf ns-allinone-2.27.tar.gz
  4. wget http://www.tekno.chalmers.se/~yusheng/reports/ns-2.27-gcc410.patch
  5. patch -p0 < ns-2.27-gcc410.patch (설치시 Ubuntu package 과정 및 업데이트 되어있어야함!)
  6. cd ns-allinone-2.27/
  7. ./install
  8. 설치후에 bash_profile, vimrc를 넣는다.(vim bash_profile해서 수정하여야함!!IP주소등..참고로 .bash_profile을 사용해서 숨긴다.)

-출처:http://tmtam.wordpress.com/2007/07/31/installing-ns-227-and-leach-extension-on-ubuntu-704-feisty-fawn/ -

[출처] Install NS-2.27 and Ubuntu|작성자 울라짱구


LEACH 설치

 

1) 실행 : /home/cjm/ns-allinone-2.27/ns-2.27 디렉토리에서

./test

 

(ns tcl/ex/wireless.tcl -sc mit/uAMPS/sims/100nodescen -rp leach -x
1000 -y 1000 -nn 101 -stop 100 -eq_energy 1 -init_energy 2 -filename
leach_file -dirname leach_dir -num_clusters 5 -bs_x 0 -bs_y 0)

 

 

2) 설치 단계(gcc 버젼 확인,,, 4.1.2 이상 권장)

 

Step 1: Download NS-2.27

다운로드 : wget http://www.isi.edu/nsnam/dist/ns-allinone-2.27.tar.gz

압축 해제 : tar zxvf ns-allinone-2.27.tar.gz

 

Step 2: You need to apply a patch to ns-2.27 to make it works with gcc4.1. You can get the patch here

gcc 다운 : wget http://www.tekno.chalmers.se/~yusheng/reports/ns-2.27-gcc410.patch

위치 : ns-allinone-2.27 디렉토리 밖에서

패치 : patch -p0 <ns-2.27-gcc410.patch in bash

 

Step 3 : tk-8.4 최신버전으로 패치

위치 : cd ns-allinone-2.27/tk8.4.5

패치 : patch -p0 < tk-8.4-lastevent.patch

 

Step 4 : ns-allinone-2.27 인스톨

위치 : cd ns-allinone-2.27

설치 : ./install

 

Step 5 : Add the environmental variables to /etc/profile

NS=/srv/ns-allinone-2.27

export PATH=$PATH:$NS/bin:$NS/tcl8.4.5/unix:$NS/tk8.4.5/unix:$NS/ns-2.27:$NS/nam-1.13

export LD_LIBRARY_PATH=$NS/otcl-1.8:$NS/lib:$/usr/X11R6/lib:$/usr/local/lib

export TCL_LIBRARY=$NS/tcl8.4.5/library:$/usr/lib
source /etc/profile

 

Step 5-1 : 만약 cygwin으로 NS2를 실행하기 위해서는 startxwin.bat 실행
위치 : cygwin 실행창

실행 : startxwin.bat

출력화면 : startxwin.bat - Starting on Windows NT/2000/XP/2003

Step 6 : ns확인

위치 : cd ns-allinone-2.27/ns-2.27

실행 : ns tcl/ex/simple.tcl

 

Step 7 : Download LEACH code, extract it under ~ns-2.27/ directory.

위치 : cd ns-2.27

다운로드 : wget http://www.internetworkflow.com/downloads/ns2leach/mit.tar.gz
압축 해제 : tar zxvf mit.tar.gz

 

Step 8 : Add the following line in ~ns2.27/mac/wireless-phy.cc, line 59, that is, after the line #define max(a,b) (((a)<(b))?(b):(a))
#define min(a,b) (((a)>(b))?(b):(a))

 

Step9 : Install the LEACH code by following instructions below:

Step 5.1: Edit the Makefile as follows:
Add DMIT_uAMPS to the DEFINE list
Add -I./mit/rca -I./mit/uAMPS to the INCLUDE list
Add the following just prior to the line gaf/gaf.o \
mit/rca/energy.o mit/rca/rcagent.o \
mit/rca/rca-ll.o mit/rca/resource.o \
mac/mac-sensor-timers.o mac/mac-sensor.o mit/uAMPS/bsagent.o \

Step 5.2 : Add the environmental variables to /etc/profile
export RCA_LIBRARY=$NS/ns-2.27/mit/rca
export uAMPS_LIBRARY=$NS/ns-2.27/mit/uAMPS

Step 5.3: source /etc/profile and clean up previous build
source /etc/profile
make clean

Step 5.4: Rebuild ns2, redirecting output
make  ( or  => nohup make 2>error.log >make.log & )

Step 10 : Test default wireless demo and LEACH
./test

 

Step 11 : Validate the full installation, redirect the output
nohup ./validate-full 2> validate.error >validate.log &

[출처] NS2- LEACH 설치 방법|작성자 둘리




신고

'research > Simulation & Performance Evaluation' 카테고리의 다른 글

ns2 LEACH extension installing  (9) 2009.10.05
Posted by 나마스떼

댓글을 달아 주세요

  1. ukdissertationwritinghelp 2011.01.26 14:54 신고  댓글주소  수정/삭제  댓글쓰기

    It’s a great tip on Do It yourself stuff. Thanks!

  2. ukdissertationwritinghelp 2011.01.26 14:54 신고  댓글주소  수정/삭제  댓글쓰기

    It’s a great tip on Do It yourself stuff. Thanks!

  3. term paper assignment 2011.04.09 19:17 신고  댓글주소  수정/삭제  댓글쓰기

    It’s very rare that you find the relevant information on the net but your article did provide me the relevant information. I am going to save your URL and will definitely visit the site again.

  4. Tablet Android Honeycomb Terbaik Murah 2011.08.15 19:27 신고  댓글주소  수정/삭제  댓글쓰기

    이 사이트에 우리의 제 3의 휴가는 것입니다. 이 블로그 사이트 때문에 단순히 아주 같은 전문적인 틈새 안에 새로운 프로젝트를 시작했다. 귀하의 블로그 게시물은 사용 사람 중요한 데이터를 가구. 당신은 훌륭한 일을 했어. 자신의 피부 색상을 보존할 수 사랑스러운 여자 문제와 함께 방법을 plumped 그 자신의 무기가이 사람을 얻을 것이다 지켜보고 결국.

  5. mesothelioma lawyers 2011.08.16 16:29 신고  댓글주소  수정/삭제  댓글쓰기

    선물 감싸 관련된 훌륭한 팩의 그! 난 당신이 그들 모두 (항상되지 않습니다?)에 대해 매우 걱정하고 있고 볼 수 있습니다. 당연히 당신은 송곳니 돌을을 수행할 수 있습니다. 난 그녀가 매우 신속하게 밖으로 작동한 폭풍 인형을 인수했습니다. 더 많은 강아지 간식을 읽어 모든. 인터넷 마케팅 기쁘게 사람이 현재 선물을 좋아했습니다.

  6. Lawyer Marketing 2011.08.18 06:13 신고  댓글주소  수정/삭제  댓글쓰기

    당신은 완전히 당신이 달 일이 작업을 통해 지출을 방문 무료입니다. 그들이 고려 수있는 이야기에 대해 정확하게 일반적으로 문제가없는 사람 때문에 세계는 훨씬 더 열렬한 아웃소싱 헬퍼를 기원합니다. 일반적으로 현재 심혈관 가신 답니다.

  7. Ban Terbaik di Indonesia GT Radial 2011.11.24 13:35 신고  댓글주소  수정/삭제  댓글쓰기

    내가 아주이 블로그에 대한 즐길입니다. 그 정보를 주제. 그것은 몇 가지 문제를 해결하기 위해 절 그다지 도움이됩니다. 그 기회가 너무 빠른 너무 환상적이고 일하는 스타일입니다. 난 당신이 모두 도움이 될 것 같아요. 나와 함께이 아름다운 블로그를 즐기는 줘서 고마워. 나는 정말 그것을 감사 해요! 다른 훌륭한 블로그를 기대하겠습니다.작성자에게 행운을 빕니다! 모두 제일 좋다

  8. ultrabook notebook tipis harga murah terbaik 2012.01.29 14:16 신고  댓글주소  수정/삭제  댓글쓰기

    시작하기 위해 내 배우자를 언급하고 새로운 설문 조사가 부가 확인란되고이 후 의견을 포함시킬 수 때 같은 검토를 고집 일부 메시지를 구입하는 동안 당신 - 알림을해서 교전이 동안. 아마 그러나 당신이 도움이됩니다 통해 멀리 데려다해야 있나요? 건배!

  9. AGEN BOLA 2012.08.20 12:24 신고  댓글주소  수정/삭제  댓글쓰기

    agen bola bv berkomentar situs anda sangat menarik dan saya harap anda terus mengembangkanya 귀하는 차단되었으므로 사용

XShell 한글 지원

research 2009.10.05 15:40

우분투 EUC-KR 설치

#sudo apt-get install language-pack-ko

#sudo locale-gen ko_KR.EUC-KR

GNOME 한글세팅은 여기서

1. /etc/environment 설정값 바꾸기

$ sudo vim /etc/environment

2. 환경 바꾸기

LANG="ko_KR.UTF-8"

LANGUAGE="ko_KR:ko:en_GB:en"

위에와 같이 선택이 되어있다. EUC-KR를 추가해주자.

LANG="ko_KR.UTF-8"

LANG="ko_KR.EUC-KR"

LANGUAGE="ko_KR:ko:en_GB:en"

3. 재부팅한다.

신고

'research' 카테고리의 다른 글

XShell 한글 지원  (0) 2009.10.05
ubuntu에 tinyos 설치  (1) 2009.09.30
SVM  (0) 2009.08.31
BibTeX in Latex with WinEdt / WinEdit + MikTEx  (0) 2009.05.11
permasense Project  (0) 2009.03.18
Posted by 나마스떼

댓글을 달아 주세요

출처: http://blog.byfun.com/351
신고

'research' 카테고리의 다른 글

XShell 한글 지원  (0) 2009.10.05
ubuntu에 tinyos 설치  (1) 2009.09.30
SVM  (0) 2009.08.31
BibTeX in Latex with WinEdt / WinEdit + MikTEx  (0) 2009.05.11
permasense Project  (0) 2009.03.18
Posted by 나마스떼

댓글을 달아 주세요

  1. 나마스떼 2009.10.02 19:30 신고  댓글주소  수정/삭제  댓글쓰기

    http://blog.naver.com/PostView.nhn?blogId=finalyu&logNo=20057678652&widgetTypeCall=true

NIKON CORPORATION | NIKON D100 | Aperture priority | Center-weighted average | 1/320sec | F/1.8 | 0.00 EV | 35.0mm | ISO-200 | Flash did not fire | 2009:09:16 17:11:45
NIKON CORPORATION | NIKON D100 | Aperture priority | Center-weighted average | 1/400sec | F/1.8 | 0.00 EV | 35.0mm | ISO-200 | Flash did not fire | 2009:09:16 17:11:48
NIKON CORPORATION | NIKON D100 | Aperture priority | Spot | 1/60sec | F/1.8 | 0.00 EV | 35.0mm | ISO-200 | Flash did not fire | 2009:09:16 17:27:03

신고

'세상사는 이야기 > 나만의 일상' 카테고리의 다른 글

머리자르고  (0) 2009.09.16
7월 3일 도시락  (1) 2009.07.03
6월 24일 도시락  (0) 2009.06.24
수영첫날  (0) 2009.06.23
6월 23일 도시락  (0) 2009.06.23
6월 22일 도시락  (0) 2009.06.22
Posted by 나마스떼

댓글을 달아 주세요

SVM

research 2009.08.31 20:40
Support Vector Machines is a powerful methodology for solving problems in nonlinear classification, function estimation and density estimation which has also led to many other recent developments in kernel based methods in general. Originally, it has been introduced within the context of statistical learning theory and structural risk minimization. In the methods one solves convex optimization problems, typically quadratic programs. Least Squares Support Vector Machines (LS-SVM) are reformulations to the standard SVMs which lead to solving linear KKT systems. LS-SVMs are closely related to regularization networks and Gaussian processes but additionally emphasize and exploit primal-dual interpretations. Links between kernel versions of classical pattern recognition algorithms such as kernel Fisher discriminant analysis and extensions to unsupervised learning, recurrent networks and control are available. Robustness, sparseness and weightings can be imposed to LS-SVMs where needed and a Bayesian framework with three levels of inference has been developed. LS-SVM alike primal-dual formulations have been given to kernel PCA, kernel CCA and kernel PLS. For ultra large scale problems and on-line learning a method of Fixed Size LS-SVM is proposed. The present LS-SVMlab toolbox contains Matlab/C implementations for a number of LS-SVM algorithms.
신고

'research' 카테고리의 다른 글

XShell 한글 지원  (0) 2009.10.05
ubuntu에 tinyos 설치  (1) 2009.09.30
SVM  (0) 2009.08.31
BibTeX in Latex with WinEdt / WinEdit + MikTEx  (0) 2009.05.11
permasense Project  (0) 2009.03.18
Posted by 나마스떼

댓글을 달아 주세요

TCP Performance and the Mathis Equation

Good network engineers know about TCP performance over Long, Fat Networks (LFNs - see RFC1323) and how to use bandwidth, delay, and window size to calculate the maximum throughput of a connection.  But it seems that not many people know about the Mathis Equation, which describes how packet loss factors into the throughput calculations.

For those not familiar with it, the buffering required in a receiving system for maximum performance is based on the BW-Delay Product (BDP).  It is the amount of data that can be sent between ACKs.  You multiply the path's minimum bandwidth by the round-trip delay.  The table below shows the buffering requirements for several examples, with the BW converted to Bytes/Sec and the Delay converted to Sec, resulting in the BDP units of Bytes.

BW (Mbps) RT Delay (ms) Bytes/Sec Delay (Sec) BDP (Bytes)
1.533 5 191,625 0.005 958
10 5 1,250,000 0.005 6,250
45 5 5,625,000 0.005 28,125
100 5 12,500,000 0.005 62,500
1000 5 125,000,000 0.005 625,000
1.533 20 191,625 0.020 3,833
10 20 1,250,000 0.020 25,000
45 20 5,625,000 0.020 112,500
100 20 12,500,000 0.020 250,000
1000 20 125,000,000 0.020 2,500,000
1.533 60 191,625 0.060 11,498
10 60 1,250,000 0.060 75,000
45 60 5,625,000 0.060 337,500
100 60 12,500,000 0.060 750,000
1000 60 125,000,000 0.060 7,500,000

When the TCP window size is more than the BDP, the path BW is the limiting factor in throughput.  But when the TCP window size is less than the buffering required to keep the pipe filled, we use another equation to calculate the maximum throughput of the path.  The sending system will send a full TCP window worth of data and then wait for an acknowledgement from the receiver.  When the ACKs are received, more data can be sent.  Therefore, the maximum throughput is the window size divided by the time it takes to get back an ACK (i.e., the round trip time).

An example is useful to illustrate what happens here.  Let's say that we want to transfer a large file from a server to our workstation and that the workstation supports a TCP window size of 65535.  The path between the server and the workstation is T3 speeds (45Mbps) and the two systems are separated by a terrestrial link that's 3000 miles long.  One-way delay on terrestrial links is nominally 10ms per 1000 miles, so our link is 30ms long, one-way and 60ms round-trip.

The amount of buffering required is the link speed, converted to bytes, times the delay, in seconds.
Buffering = BW * Delay = 45,000,000/8 Bytes/Sec * .06 Sec = 337,500 Bytes.  That's bigger than our window, so we need to use the equation for TCP throughput.

Throughput = TCPWindow / round-trip-delay = 65535 Bytes / .06 Sec = 1,092,250 Bytes/Sec
                     = 8,738,000 bits/sec

That's considerably less than the T3 bandwidth that a non-technical person might expect.  If the systems support the window scaling option, the window size can be multiplied by a scaling factor in order to fill the pipe.  But many systems don't have window scaling options enabled or enough buffer space allocated to handle the high throughput for modern network paths, so throughput suffers and the people using these systems have lower productivity.

The above calculations all assume a lossless path.  This brings us to the question of what happens when the path experiences packet loss.  The formula that approximates what happens when TCP experiences loss in the path was approximated in a 1997 paper by Mathis, Semke, Mahdavi & Ott in Computer Communication Review, 27(3), July 1997, titled The macroscopic behavior of the TCP congestion avoidance algorithm

Rate < (MSS/RTT)*(1 / sqrt(p))
where p is the probability of packet loss.

This equation seems to have become known as the Mathis Equation.  Obviously, TCP performance goes down as packet loss increases, but this gives us an idea of how quickly this happens.  Fiber Bit Error Rates (BER) are typically 10E-13.  Some optical gear treats a link as down at a BER of 10E-6 (one bad bit in 1M bits).  Assuming a stream of 1460 byte packets, that's one bad packet approximately every 85 packets.  Mathis, et al., did a thorough review of what happens with high packet loss probability, which I'll not try to duplicate here; see the paper referenced below. 

 What it means

What is important for us as network engineers is to understand the impact on throughput so we can decided when to do something about it.  We should be looking for links that are experiencing BER loss that exceeds 10E-10.  A rough engineering calculation is that a packet nominally contains 10,000 bits (1250 Bytes), or 10E4 bits.  This makes the math easier and allows us to get a gut feel for the figures.  That means that we need a packet loss figure of 10E-10 (BER) - 10E-4 (the packet size in bits) = 10E-6 (packet loss rate).  Converting to a decimal number from scientific representation and we have .000001, or .0001%.  That's a number that we can use with our network monitoring systems to highlight lossy links and paths.  Statistically, there isn't much difference between this calculation and one in which you assume an average packet size of 300 Bytes.  I prefer the simpler calculation and base my network management thresholds on it. Also note that LAN interfaces should typically have a loss rate that's several orders of magnitude less than a WAN link or wireless link, so you may want to use different figures for different types of links.

Additional References

There is a good tutorial on TCP performance, with examples of fiber BER and different delays at
http://www.linuxsa.org.au/meetings/2003-09/tcpperformance.print.pdf

A validation was reported in Modelling TCP throughput: A simple model and its empirical validation by J. Padhye, V. Firoiu, D. Townsley and J. Kurose, in Proc. SIGCOMM Symp. Communications Architectures and Protocols Aug. 1998, pp. 304-314.  While this may be a more accurate analysis, it is certainly beyond the level of detail that most network engineers wish to go.

Pete Welcher also took a look at this and posted his own view and links on the topic at:
http://www.netcraftsmen.net/resources/blogs/tcp-ip-performance-factors.html

I also recommend that you read RFC1323 (May 1992) to learn more about the fundamental mechanisms that have been in place for a long time.  There are also some great references on the Internet on how to tune various TCP stacks for optimum operation over LFNs.  Understanding how to measure performance and what to do about it when it seems slow is valuable knowledge.

  -Terry
 

신고

'research > E2ENetPer' 카테고리의 다른 글

TCP Performance and the Mathis Equation  (0) 2009.08.22
성능 분석  (1) 2007.04.14
iperf로 test하기  (0) 2007.03.26
RFC-Network Performance Metric  (0) 2007.03.26
Posted by 나마스떼

댓글을 달아 주세요


AMPL, an acronym for "A Mathematical Programming Language", is a high-level programming language, developed at Bell Laboratories, for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization and scheduling type problems). AMPL does not solve those problems directly; instead, it calls appropriate external solvers (such as CPLEX, FortMP, MINOS, IPOPT, SNOPT, KNITRO, and so on) to obtain solutions. AMPL handles linear and nonlinear optimization problems as well as complementarity problems (MPECs), in discrete or continuous variables.

One particular advantage of AMPL is the similarity of its syntax to the mathematical notation of optimization problems. This allows for a very concise and readable definition of problems in the domain of optimization. Many modern solvers available on the NEOS [1] server (hosted at the Argonne National Laboratory) accept AMPL input.

AMPL was created by Robert Fourer, David Gay and Brian Kernighan. It is currently maintained by AMPL Optimization LLC.


KNITRO is a software package for solving large scale mathematical optimization problems. KNITRO is specialized for nonlinear optimization, but also solves linear programming problems, quadratic programming problems, and systems of nonlinear equations. The unknowns in these problems must be continuous variables incontinuous functions; however, functions can be convex or nonconvex. KNITRO computes a numerical solution to the problem -- it does not find a symbolic mathematical solution.

Optimization problems must be presented to KNITRO in mathematical form, and should provide a way of computing function derivatives using sparse matrices. Problems may be written in C, C++, Fortran, or Java, in which case KNITRO is called as a software routine to solve the problem. An often easier approach is to develop the optimization problem in an algebraic modeling language (AML) like AIMMS, AMPL, GAMS, Mathematica, etc. The modeling environment computes function derivatives, and KNITRO is called as a "solver" from within the environment.

KNITRO offers three different optimization algorithms for solving optimization problems. Two algorithms are of the interior point type, and one is of the active set type. These algorithms are known to have fundamentally different characteristics; for example, interior point methods follow a path through the interior of the feasible regionwhile active set methods tend to stay at the boundaries. KNITRO provides both types of algorithm for greater flexibility in solving problems, and allows crossover during the solution process from one algorithm to another. The code also provides a multistart option for promoting the computation of the global minimum.

KNITRO, short for "Nonlinear Interior point Trust Region Optimization" (the "K" is silent) was created primarily by Richard Waltz, Jorge Nocedal, Todd Plantenga and Richard Byrd. It is produced by Ziena Optimization, Inc. KNITRO was introduced in 2001 as a derivative of academic research at Northwestern, and has undergone continual improvement since.

신고

'research > mathematics' 카테고리의 다른 글

KNITRO with AMPL  (0) 2009.07.22
Cardinality  (0) 2009.05.21
bloom filter  (0) 2008.01.10
수학기호  (3) 2006.12.22
Posted by 나마스떼

댓글을 달아 주세요



티스토리 툴바