의도적으로 느린 MATLAB 기능?

StackOverflow https://stackoverflow.com/questions/1616130

문제

정말로, 정말로 느린 프로그램을 작성하고 싶습니다. MATLAB. 나는 o (2^n) 또는 더 나쁜 것처럼 말하고 있습니다. 마무리해야하고 결정적으로 느리기 때문에 "rand () = 123,123, 종료!" 이것은 미쳤지 만 실제로는 분산 시스템 테스트를위한 것입니다. .m 파일을 만들고 컴파일해야합니다 ( MCC), 그리고 분산 시스템에서 실행하여 일부 디버깅 작업을 수행하십시오.

프로그램은 지속적으로 일을해야합니다 sleep() 유효한 옵션이 아닙니다.

나는 무작위로 큰 매트릭스를 만들고 역수를 찾아 보았지만 너무 빨리 완료되었습니다. 어떤 아이디어?

도움이 되었습니까?

해결책

이산 푸리에 변환의 순진한 구현은 1.86GHz 단일 코어 머신에서 2048 긴 입력 벡터 X의 경우 ~ 9 초가 걸립니다. 4096 입력으로 이동하면 시간이 ~ 35 초로 연장되며 O (n^2)에 대해 기대할 4x에 가깝습니다. 더 긴 입력을 시도 할 인내심이 없습니다 :)

function y = SlowDFT(x)

t = cputime;
y = zeros(size(x));
for c1=1:length(x)
    for c2=1:length(x)
        y(c1) = y(c1) + x(c2)*(cos((c1-1)*(c2-1)*2*pi/length(x)) - ...
                            1j*sin((c1-1)*(c2-1)*2*pi/length(x)));
    end
end
disp(cputime-t);

편집하다: 또는 CPU보다 메모리를 더 스트레스하려는 경우 :

function y = SlowDFT_MemLookup(x)

t = cputime;
y = zeros(size(x));
cosbuf = cos((0:1:(length(x)-1))*2*pi/length(x));
for c1=1:length(x)
    cosctr = 1;
    sinctr = round(3*length(x)/4)+1;
    for c2=1:length(x)
         y(c1) = y(c1) + x(c2)*(cosbuf(cosctr) ...
                            -1j*cosbuf(sinctr));
         cosctr = cosctr + (c1-1);
         if cosctr > length(x), cosctr = cosctr - length(x); end
         sinctr = sinctr + (c1-1);
         if sinctr > length(x), sinctr = sinctr - length(x); end
    end
end
disp(cputime-t);

이것은 각 반복에서 죄와 cos를 계산하는 것보다 빠릅니다. 2048의 긴 입력은 ~ 3 초가 걸렸고 16384의 긴 입력은 ~ 180 초가 걸렸습니다.

다른 팁

2로 계산하십시오N. 선택적으로, 각 반복에서 느린 기능 호출을 만듭니다.

설정하기 쉬운 실제 작업을 원한다면 CPU가 메모리를 통해 강조합니다.

  • 큰 밀도가 높은 매트릭스 역전 (충분히 느리지 않습니까? 더 크게 만드십시오.)
  • 요인 an RSA 번호

Inv를 사용하는 것은 어떻습니까? 그랬어 보고 된 꽤 느리게.

루프에서 일을하십시오. 루프 반복 횟수를 사용하여 완료하는 데 걸리는 시간을 조정할 수 있습니다.

나는 Matlab을 말하지 않지만 다음과 동등한 것이 효과가있을 수 있습니다.

loops = 0
counter = 0
while (loops < MAX_INT) {
    counter = counter + 1;
    if (counter == MAX_INT) {
        loops = loops + 1;
        counter = 0;
    }
}

이것은 max_int*max_int times를 반복합니다. 충분하지 않으면 계산적으로 무거운 물건을 루프에 넣을 수 있습니다.

쉬운! 튜링 머신 뿌리로 돌아가서 O (2^N) 또는 더 나쁜 프로세스를 생각하십시오.

여기에 상당히 간단한 것이 있습니다 (경고, 테스트되지 않았지만 요점을 얻습니다)

N = 12; radix = 10;
odometer = zeros(N, 1);
done = false;
while (~done)
    done = true;
    for i = 1:N
        odometer(i) = odometer(i) + 1;
        if (odometer(i) >= radix)
            odometer(i) = 0;
        else
            done = false;
            break;
        end
    end
end

더 나은 것은 Fibonacci 숫자를 재귀 적으로 계산하는 것은 어떻습니까? fib (n)은 fib (n-1)와 fib (n-2)를 호출해야하지만 그 함수 중 하나만 호출하기 때문에 런타임은 O (2^N)입니다. 한 번에 발생합니다.

function y = fib(n)
   if (n <= 1)
      y = 1;
   else
      y = fib(n-1) + fib(n-2);
   end
end

당신은 그것을 요청할 수 있습니다 factor(X) 적절하게 큰 x

주어진 입력이 모든 작은 숫자로 나누어 주어지면 테스트 할 수도 있습니다. 이것은 당신에게 o (n^2)를 줄 것입니다.

이거 한번 해봐:

tic
isprime( primes(99999999) );
toc

편집하다:

보다 광범위한 테스트 세트의 경우 이러한 벤치 마크를 사용하십시오 (아마도 여러 반복에도) :

disp(repmat('-',1,85))
disp(['MATLAB Version ' version])
disp(['Operating System: ' system_dependent('getos')])
disp(['Java VM Version: ' version('-java')]);
disp(['Date: ' date])
disp(repmat('-',1,85))

N = 3000;   % matrix size
A = rand(N,N);  
A = A*A;

tic;  A*A; t=toc;
fprintf('A*A \t\t\t%f sec\n', t)

tic; [L,U,P] = lu(A); t=toc; clear L U P
fprintf('LU(A)\t\t\t%f sec\n', t)

tic; inv(A); t=toc;
fprintf('INV(A)\t\t\t%f sec\n', t)

tic; [U,S,V] = svd(A); t=toc; clear U S V
fprintf('SVD(A)\t\t\t%f sec\n', t)

tic; [Q,R,P] = qr(A); t=toc; clear Q R P
fprintf('QR(A)\t\t\t%f sec\n', t)

tic; [V,D] = eig(A); t=toc; clear V D
fprintf('EIG(A)\t\t\t%f sec\n', t)

tic; det(A); t=toc;
fprintf('DET(A)\t\t\t%f sec\n', t)

tic; rank(A); t=toc;
fprintf('RANK(A)\t\t\t%f sec\n', t)

tic; cond(A); t=toc;
fprintf('COND(A)\t\t\t%f sec\n', t)

tic; sqrtm(A); t=toc;
fprintf('SQRTM(A)\t\t%f sec\n', t)

tic; fft(A(:)); t=toc;
fprintf('FFT\t\t\t%f sec\n', t)

tic; isprime(primes(10^7)); t=toc;
fprintf('Primes\t\t\t%f sec\n', t)

다음은 하나의 반복에만 n = 1000을 사용하는 내 컴퓨터의 결과입니다 (참고 프라임은 10^7이 아닌 10^7 [더 많은 시간이 걸립니다!]).

A*A             0.178329 sec
LU(A)           0.118864 sec
INV(A)          0.319275 sec
SVD(A)          15.236875 sec
QR(A)           0.841982 sec
EIG(A)          3.967812 sec
DET(A)          0.121882 sec
RANK(A)         1.813042 sec
COND(A)         1.809365 sec
SQRTM(A)        22.750331 sec
FFT             0.113233 sec
Primes          27.080918 sec

이것은 Wanted_time 초 동안 100% CPU를 실행합니다

WANTED_TIME = 2^n; % seconds
t0=cputime; 
t=cputime; 
while (t-t0 < WANTED_TIME)
    t=cputime; 
end;
라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top