DS 's RoOm: 1월 2013

2013년 1월 28일 월요일

대용량, 대량의 파일처리관련 글(고민)

쓰레드 여러개 돌려서 파일 읽기
http://blog.daum.net/gdocument/228

하나의 파일을 여러 스레드에서 읽을때 문제없을까요? 글
http://kldp.org/node/99200

내생각. 아무래도 읽기의 경우 파일디스크립트제한(1024)
읽기의 경우는 쓰기(하나의 파일을 여러곳에서 쓸경우)와는 다르게
읽기만 하는것이니 여러스레드에서 하나의 파일을 읽어도 문제가 되지 않을거라고 생각된다.

대용량[수백메가 ~수기가] 파일처리 관련 글
http://kldp.org/node/89220

2013년 1월 25일 금요일

Select() 입출력 다중화

참고
Joinc: select를 이용한 입출력 다중화

입출력 다중화는 단일 프로세스에서 여러개의 파일을 제어할수 잇도록 한다.
입출력 다중화는 "비동기/ 봉쇄입출력 모델"

입출력 다중화는 여러개의 파일을 다루기 위해서 파일기술자를 배열(그룹)으로 관리한다.
개발자는 배열의 값을 검사하는것으로 여러개의 파일을 처리할수잇게된다.

입출력 다중화의 모델의 제한

1. 파일기술자 테이블의 크기 처리할수 잇는 파일의 최대크기는
프로세서가 열수 있는 파일의 최대개수와 별도로 "파일 기술자 테이블의 크기"에 영향을 받느다.
일반적으로 파일 기술자 테이블의 크기는 1024인데 , ulimit(1)등으로 변경할수없다.(?잉 변경할수 없는건가요? -_- 찾아보세요~)
(파일기술자 단일비트필드 테이블이라는것에 주목 변경해야할 필드가 있다면 1을 리턴한다.
그렇다면 111111..111로 AND연산을 하는것인가?)

2. 배열로써 가지는 성능 문제 이벤트 기반이 아니기 때문에
배열을 순차적으로 모든값을 전부검사해야한다.
만약 1000개의 클라이언트가 연결되어있고, 이중 어느 하나에 데이터변경이
이뤄졌다면 최악의 경우 1000개의 필드 모두 검사해야하는...문제가
(연결파일의 목록을 별도의 배열에 유지하는것으로 어느정도 문제를 해결할수 잇기는 하다.-=
완전한 방법은 아니다. 연결된 파일이 하나고 이 파일의 지정번호가 1000이라면
1번만 비교할수있지만 , 연결된 파일이 1000이라면 여전히 1000번의 루프를 돌아야한다. ㅠㅠ)

3. 병렬처리가 아니다. 이 모델은 멀티스레드와 병렬처리가 아니다.
데이터를 읽어서 처리하는 응답시간"동안 다른파일은 대기해야하므로
데이터 처리 과정이 긴 서비스에는 적용하기에는 적당한 모델이 아니다.
즉 데이터처리과정이 짧은 메시지 전달 서비스에 적합한 모델이라는것.

이러한 단점이 있지만 매우 견고한 모델이며, 프로그래밍 기술이 단순하기 때문에
널리 사용되고있다.

2013년 1월 24일 목요일

c# 파일, 디렉토리복사이동삭제 관련

파일관련된 작업을 했습니다.

특정 폴더를 복사, 이동 하려합니다.
특정폴더 밑에는 폴더들과 파일들이 존재하는데
이 모든것들을 대상 경로에 복사, 이동해야합니다.

msdn 파일 및 폴더 복사 , 삭제 및 이동
http://msdn.microsoft.com/ko-kr/library/cc148994.aspx

이동 이나 삭제 같은경우 메소드가 존재 합니다.
Directory.Move()
Directory.Delete()
하지만 파일 복사시 위의 경우처럼 특정폴더 하위에
폴더나 파일들이 존재한다면

폴더들을 CreateDirectory로 일일이 만들어줘야하고
파일들도 각각 Copy해야하는것 같습니다. msdn 참고 한 결과 이렇게 해줘야 되더군요-_-
귀찮게말입니다.

파일삭제나 이동 복사, 삭제 같은경우 권한 등등을 고려해야할것 같습니다.
<권한, 존재유무,등등>
파일보안 관련한 블로그 참고 http://nsinc.tistory.com/43

(윈폼에서는 app.manifest 파일에서 아래의내용을 추가했었습죠
""

디렉토리내의 하위디렉토리까지 검색해야하는경우 재귀나 for문, 스택을 이용합니다.
재귀는 적절한 방식이기는 하지만 디렉토리의 규모가 크고 복잡하게 중첩되어 있으면
스택오버플로우 예외를 발생시킬 위험이 있다고 하는군요

msdn에서 디렉토리 트리반복으로 가이드가 있군요
http://msdn.microsoft.com/ko-kr/library/bb513869.aspx

c#에서 운영체제를 확인하는
OperatingSystem os = Environment.OSVersion;
string osname = os.versionString;

결과값: os.VersionString = "Microsoft Windows NT 6.1.7601 Service Pack 1"
win2008 = "6.0.6002";
win2003 = "5.2.3790";
win7 = "6.1.7601";

2013년 1월 14일 월요일

Encoding 'euc-kr' not support발생...

jmaster.dat 파일(ISO-8859 : 컴퓨터에서 8비트 문자를 나타냄)로 작성됨(file <파일명>으로확인)

이떄 ISO-8859은 한글을 표현할수가 없다고 한다. 그러니까 ISO-8859파일에서의 한글은

그부분을 euc-kr 또는 utf-8로 작성되어 insert되있다고(?) 한다(구글링 검색 KLDP 한 글에서)

이파일을 리눅스(우분투 10.04.4 LTS)에서 파일을 읽었더니 해당 글자가 깨지거나

compile(C# - mono)할시 Encoding Not Supported "euc-kr" 이라는 에러가 출력하는것이 아닌가.

서버이전해서 이문제가 발생...

언어설정이 잘못되어있는지... echo $LANG,

/etc/environment 등 구글링..검색 이전서버와 동일 환경인데 왜 문제가 발생했던 것이다.

30분동안 검색결과 c# 컴파일해주는 Mono에서 문제가 발생했던것.

mono용 i18n 을 업데이트 해주라는말이었다..

잉? 분명히 이전 서버와 동일했는데 말이다.

"apt-get install libmono-i18n2.0-cil " 실행후

컴파일하니까 제대로..나온다.-_-

다행이 빠른시간안에 찾앙서 성공!!!!

ISO-8859 언어셋 euc-kr , utf-8,

bianry 파일읽은것에대해 공부좀 해야겠다.

<변경사항>
아아 이런 위의 Mono문제가 있었을 뿐더라 다른 문제가 발생햇다.

위에서 언급했듯이 ISO-8859파일에서의 한글은 표현할수가 없으므로
euc-kr 혹은 utf-8로 작성되어 인서트되잇다고 했다.

그러므로 파일을 열어서 파일포인터로 해당 위치부분만 euc-kr 혹 utf-8로 읽어서
Encoding하여 처리해야한다는것입니다!!!

그외의 파일부분은 ISO-8859-1로 읽어들었더니 잘 됬습죠
이히히히

2013년 1월 7일 월요일

효과적인 C# 메모리 관리 방법

마이크로소프트웨어 효과적인 c#메모리관리기법

말 그대로 효과적인 C#메모리 관리 방법에대해 알아본다.
1. '+' operator를 통한 문자열 조합
위의 문제는 가비지가 많이 발생한다. '+' 연산자로 두값을 연결할때마다
새로운 string 인스턴스가 생성된다. 연이어 + 연산자가 나오기 때문에
또 string인스턴스가 생성되고 이전에 만들어진 string인스턴스는 가비지가 된다.
=> StringBuilder객체를 생성하여 사용하자

2. 메소드 안에서 생성한 객체
C#은 c++과달리 클래스를 인스턴스하려면 반드시 new를 해줘야한다. (이때 Heap에 메모리할당)
특정 메소드안에서 new로 생성된 인스턴스는 메소드를 빠져나오면 더 이상 사용하지 않게 돼
가비지로 처리된다. 이러한 패턴의 메소드가 자주 호출될수록 가비지도 많이 발생된다.
=> 클래스를 구조체로 바꿔보면 new연산자로 인스턴스를 만들어도 Heap영역에 메모리가
할당되지 않는다 구조체 역시 Value Type이기 때문에 Stack영역에 할당되며 메소드를 빠져나갈경우
자동으로 삭제된다. Heap영역이 아니므로 가비지컬렉션의 대상이 되지않는다.
구조체도 싫다면 맴버변수로 사용한다.

3. 속도 저하가 큰 Boxing
Boxing이란 Value Type객체를 Reference Type객체로 포장하는 과정을 뜼함
c#의 모든 객체는 object로 상속되는데 심지어 상속받지 못하는
int, float등의 Value Type조차도 object로부터 상속된것처럼 사용할수 이싸ㄸ.
하지만 가비지 컬렉션에의한 부하 못지않게 Boxing으로 인한 부하도 크다.

=> 다양한 Type을 처리하는 경우가 아니라면 Collections에 사용된 값의 type을 명시해
주는 Generic Collection 사용을 권한다...
List List 이런것.?
즉 되도록 Boxing과 UnBoxing을 최소화하라는 의미.. Effective C# 정리에서 Boxing, UnBoxing 내용

4. WeakReference로 의도하지 않은 참조를 없애보자
인스턴스를 참조 하는 모듈에서 WeakReference를 사용하면 의도하지 않은 참조로
메모리가 해제되지 않는 실수를 방지할수 있다. 주의할점은 WeakReference.Target값을
보관하면 안된다는것, 만약 보관하고있다면 강한참조(Strong Reference)가 일어나 이를 인식한
가비지컬렉터는 회수를 실행하지 않는다.

5. GC 가비지 컬렉션처럼 원하는 시점에 없애고 싶다면... IDisposal
.IDisposal 인터페이스를 구현한 클래스를 생성하고 Dispose()메소드 내에서 리소스를해제!

2013년 1월 4일 금요일

쓰레드 몇개해야 만들어야될까?

크기가작은 파일이 무수히 많다.(KB)
크기가 큰 파일이 무수히 많은경우
하나의 스레드에서 작업한다면 오래 걸릴것이다.

스레드를 많이 생성하여(Main Thread가 여러개의 스레드를 생성) 이 작업을 한다면 속도가 빨라져
시간을 단축할수있다.(병렬처리의 가장 흔한방식 )

- 스레드개수가 많아질수록 성능향상의 정도는 줄어든다.
- 스레드가 너무 많아지면 속도가 조금 빨라질수 있지만 응답속도가 떨어진다.

즉 프로세스 개수 대비 적당한 스레드개수를 정해야한다(cpu의 성능 , i/o 입출력)
스레드가 필요할때마다 생성해서 사용하기보단
쓰레드풀을 이용하여 사용하고 자원이 반납되어진 즉 대기중인 스레드를 가져와서 사용하면 효율성이 업업
Boss/ Worker
BOss스레드(일반적MainThread)가 여러 개의 Worker스레드에게 작업을 나누어주는방식

Client/Server model
동시에 여러개의 클라이언트들의 요구를 처리하기위해 스레드를 연결된 클라이언트마다 생성한다.

PipeLineModel
각 스레드 또는 스레드들의 그룹은 주어진 작업에 대한 특정한 처리를 수행하고
그것을 다른 스레드에게 넘겨서 나머지 처리가 일어나게한다.
Divide &Conquer 전략이 얼핏보면 비슷한거같다.

웹기반 시스템에서의 성능 관한글 보기

2013년 1월 2일 수요일

Parallel 예제모음

병렬 프로그래밍
Parallel Programming
병렬처리는
Data Parallellism 대량의 데이터를 처리하는데 있어 각 CPU에 일감을 나눠서 주고 동시에 병렬로 처리
즉 대량의 데이터를 분할하여 다중 CPU를 사용하고 다중스레드들이 각각 할당된 데이터를 처리하는데
일반적으로 스레드 당 처리 내용은 동일하다.
(PLINQ와 Parallel클래스(For, Foreach메소드)

Task Parallelism은 큰 작업 Task를 분할하여 각 스레드들이 나눠서 다른 작업 Task들을 실행하는것
Task, TaskFactory (Parallel.Invoke())
PLINQ
PLINQ는 LINQ쿼리들을 병렬로 처리한다.
프레임워크의 작업분할,결과들을 처리하는 부담을 줄이는 이점이 있다?
AsParallel()을 호출하여 3 ~ 100,000 사이의 소수를 구하는 예제를 보자
LINQ 쿼리를 입력으로 하는
AsParallel은 System.Linq.ParallelEnumerable을 확장 메소드로

struct IndexedWord { public string Word; public int Index; }

public static void Main(string[] args)
        {

/*
           IEnumerable<int> numbers = Enumerable.Range(3, 500 - 3);
           var parallelQuery = from n in numbers.AsParallel()
                               where Enumerable.Range(2, (int)Math.Sqrt(n)).All(i => n % i > 0)
                               select n;
           int[] primes = parallelQuery.ToArray();
           foreach (int nn in primes)
               Console.Write(nn + " ");
           Console.ReadLine();

//############################
           if (!File.Exists("WordLookup.txt"))
               new WebClient().DownloadFile("http://www.albahari.com/ispell/allwords.txt", "WordLookup.txt");
            
           var wordLookup = new HashSet<string>(
                   File.ReadAllLines("WordLookup.txt"),
                   StringComparer.InvariantCultureIgnoreCase);

var random = new Random();
           string[] wordList = wordLookup.ToArray();

string[] wordsToTest = Enumerable.Range(0, 1000000)
                   .Select(i => wordList[random.Next(0, wordList.Length)]).ToArray();

wordsToTest[12345] = "woozsh";
           wordsToTest[23456] = "wubsite";

var query = wordsToTest
               .AsParallel()
               .Select((word, index) => new IndexedWord{ Word = word, Index = index})
               .Where(iword => !wordLookup.Contains(iword.Word))
               .OrderBy(iword=> iword.Index);

Console.WriteLine(query.Count());
           foreach (IndexedWord w in query)
           {
               Console.WriteLine("Index: {0}, Word: {1}", w.Index, w.Word);
                
           }
            //############################
           int j = 0;
           var query = from n in Enumerable.Range(0, 999).AsParallel()
                       select n * j++;

var query2 = Enumerable.Range(0, 999).AsParallel().Select((n, i) => n * i);

Camera[] cameras = Enumerable.Range(0, 4)
               .Select(i => new Camera(i))
               .ToArray();

while (true)
           {
               string[] data = cameras.AsParallel().AsOrdered().WithDegreeOfParallelism(4)
                   .Select(c => c.GetNextFrame()).ToArray();
               Console.WriteLine(string.Join(", ", data));
           }
            
            //############################
            IEnumerable<int> million = Enumerable.Range(3, 1000000);

var cancelSource = new CancellationTokenSource();
            var primeNumberQuery =
                from n in million.AsParallel().WithCancellation(cancelSource.Token)
                where Enumerable.Range(2, (int)Math.Sqrt(n)).All(i => n % i > 0)
                select n;

new Thread(() =>
            {
                Thread.Sleep(100);
                cancelSource.Cancel();
            }).Start();

try
            {
                int[] primes = primeNumberQuery.ToArray();
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Query canceled");
            }
             * "abcedf".AsParallel().Select(c => char.ToUpper(c)).ForAll(Console.Write);
            //############################

int[] numbers = { 0, 2, 3, 4 };
            int sum = numbers.Aggregate(0, (total, n) => total + n);
            //  Console.WriteLine(sum);

int[] numbers2 = { 1, 2, 3 };
            int x = numbers2.Aggregate(0, (prod, n) => prod * n);
            int y = numbers2.Aggregate((prod, n) => prod * n);

int sum2 = numbers.Aggregate((total, n) => total + n * n);
            //  Console.WriteLine("d "+sum2);

int sum3 = numbers.Select(n => n * n).Aggregate((total, n) => total + n);
            //  Console.WriteLine("d " + sum3);
            numbers.AsParallel().Aggregate(
                () => 0, (localTotal, n) => localTotal + n, // seedFactory
                (mainTot, localTot) => mainTot + localTot,  //  updateAccumulatorFunc
                finalResult => finalResult);                //  resultSelector
           
            //#####################################
            string text = "Let's suppose this is a really long string";
            var letterFrequencies = new int[26];
            foreach (char c in text)
            {
                 int index = char.ToUpper(c) - 'A';
                  if (index > 0 && index <= 26) letterFrequencies[index]++;
            };

int[] result = text.AsParallel().Aggregate(
                    () => new int[26],
                    (localFrequencies, c) => // Aggregate into the local accmulator
                    {
                        int index = char.ToUpper(c) - 'A';
                        if (index >= 0 && index <= 26) localFrequencies[index]++;
                        return localFrequencies;
                    },
                    (mainFreq, localFreq) =>            //  Aggregate local ->main accumulator
                            mainFreq.Zip(localFreq, (f1, f2) => f1 + f2).ToArray(),
                            
                            finalResult => finalResult  //  Perform any final transformation
                                                                );
     
            //#####################################
            var data = new List<string>();
            Parallel.Invoke(
                () => data.Add(new WebClient().DownloadString("http://www.foo.com")),
                () => data.Add(new WebClient().DownloadString("http://www.naver.com")));
  
            var keyPairs = new string[6];
            Parallel.For(0, keyPairs.Length, i => keyPairs[i] = RSA.Create().ToXmlString(true));

string[] keyPiarss = ParallelEnumerable.Range(0, 6)
                                .Select(i => RSA.Create().ToXmlString(true))
                                .ToArray();
            
           
            Task.Factory.StartNew(() => Console.WriteLine("Hello from a task!"));
            Task<string> task = Task.Factory.StartNew<string>(() =>
                    {
                        using (var wc = new System.Net.WebClient())
                        {
                            return wc.DownloadString("http://linqpad.net");
                        }
                    });
            string result = task.Result;
            //Console.WriteLine(result);
             
            Console.WriteLine("+================");

var task2 = new Task(() => Console.WriteLine("HEll!!!!!!!!!o!!"));
            task2.Start();

var task3 = Task.Factory.StartNew(Greet, "HElLOOO");
            task3.Wait();

var task4 = Task.Factory.StartNew(state => Greet("hello"), "grettingState");
            Console.WriteLine(task4.AsyncState);
            task4.Wait();
             */

Task parent = Task.Factory.StartNew(() =>
                {
                    Console.WriteLine("I am a parent");

Task.Factory.StartNew(() =>
                    {
                        Console.WriteLine("I am detached");
                    });

Task.Factory.StartNew(() =>
                    {
                        Console.WriteLine("I am a child");
                    }, TaskCreationOptions.AttachedToParent);
                });
            Console.ReadLine();
        }

DS 's RoOm