Làm thế nào tôi có thể phân bổ trước một chuỗi trong Perl?

Question

Tôi có một tập lệnh Perl mà crunches rất nhiều dữ liệu. Có một loạt các biến chuỗi bắt đầu nhỏ nhưng phát triển thực sự lâu do việc sử dụng lặp lại của toán tử dấu chấm (concatentation). Sẽ phát triển chuỗi theo cách này dẫn đến tái phân bổ lặp đi lặp lại? Nếu có, có cách nào để phân bổ trước một chuỗi không?

Answer 1

Đề xuất thay thế sẽ dễ dàng hơn nhiều để đối phó với: push các chuỗi trên một mảng và join khi bạn hoàn tất.

Answer 2

Có, các chuỗi mở rộng mà bạn biết sẽ phát triển là một ý tưởng hay.

Bạn có thể sử dụng toán tử 'x' để thực hiện việc này. Ví dụ, để preallocate 1000 không gian:

$ s = "" x 1000:

Answer 3

chuỗi Perl là có thể thay đổi, vì vậy phụ thêm vào một chuỗi làm KHÔNG phải chịu một hình phạt chuỗi trùng lặp.

Bạn có thể thử tất cả những gì bạn muốn tìm một cách "nhanh hơn", nhưng điều này có mùi thực sự xấu về tối ưu hóa sớm.

Ví dụ, tôi đã đánh lừa một lớp trừu tượng hóa công việc khó khăn. Nó hoạt động hoàn hảo, nhưng nó, cho tất cả các thủ thuật ngốc nghếch của nó, thực sự chậm.

Dưới đây là kết quả:

  Rate magic normal 
magic 1.72/s  -- -93% 
normal 23.9/s 1289%  -- 

Vâng, đúng vậy, Perl nhanh hơn những gì tôi nghĩ là một việc thực hiện đáng kính 1200%.

Lập hồ sơ cho mã của bạn và tìm ra vấn đề thực sự là gì, đừng thử tối ưu hóa nội dung thậm chí không phải là vấn đề đã biết.

#!/usr/bin/perl 

use strict; 
use warnings; 

{ 

    package MagicString; 
    use Moose; 

    has _buffer => (
     isa => 'Str', 
     is => 'rw', 
    ); 
    has _buffer_size => (
     isa  => 'Int', 
     is  => 'rw', 
     default => 0, 
    ); 
    has step_size => (
     isa  => 'Int', 
     is  => 'rw', 
     default => 32768, 
    ); 
    has _tail_pos => (
     isa  => 'Int', 
     is  => 'rw', 
     default => 0, 
    ); 

    sub BUILD { 
     my $self = shift; 
     $self->_buffer(chr(0) x $self->step_size); 
    } 

    sub value { 
     my $self = shift; 
     return substr($self->{buffer}, 0, $self->{_tail_pos}); 
    } 

    sub append { 
     my $self = shift; 
     my $value = shift; 
     my $L  = length($value); 
     if (($self->{_tail_pos} + $L) > $self->{_buffer_size }){ 
      $self->{buffer} .= (chr(0) x $self->{step_size}); 
      $self->{_buffer_size} += $self->{step_size}; 
     } 
     substr($self->{buffer}, $self->{_tail_pos}, $L, $value); 
     $self->{_tail_pos} += $L; 
    } 
    __PACKAGE__->meta->make_immutable; 
} 


use Benchmark qw(:all :hireswallclock); 

cmpthese(-10 , { 
     magic => sub{ 
      my $x = MagicString->new(); 
      for (1 .. 200001){ 
       $x->append("hello"); 
      } 
      my $y = $x->value(); 
     }, 
     normal =>sub{ 
      my $x = ''; 
      for (1 .. 200001){ 
       $x .= 'hello'; 
      } 
      my $y = $x; 
     } 
    }); 
#use Data::Dumper; 
#print Dumper(length($x->value())); 

Answer 4

Có, Perl đang phát triển một chuỗi sẽ dẫn đến lặp lại reallocations. Perl phân bổ thêm một chút không gian cho các chuỗi, nhưng chỉ một vài byte. Bạn có thể thấy điều này bằng cách sử dụng Devel :: Peek. Sự phân bổ lại này rất nhanh và thường không thực sự sao chép bộ nhớ. Tin tưởng người quản lý bộ nhớ của bạn, đó là lý do tại sao bạn đang lập trình trong Perl và không C. Benchmark nó đầu tiên!

Bạn có thể preallocate mảng với $#array = $num_entries và một băm với keys %hash = $num_keys nhưng length $string = $strlen không hoạt động. Đây là số clever trick I dug up on Perlmonks.

my $str = ""; 
vec($str, $length, 8)=0; 
$str = ""; 

Hoặc nếu bạn muốn tham gia XS, bạn có thể gọi SvGROW().

đề xuất hỗn loạn 'để sử dụng một mảng và sau đó kết hợp tất cả lại với nhau sẽ sử dụng nhiều hơn gấp đôi bộ nhớ. Bộ nhớ cho mảng. Bộ nhớ cho mỗi vô hướng được phân bổ cho từng phần tử trong mảng. Bộ nhớ cho chuỗi được giữ trong mỗi phần tử vô hướng. Bộ nhớ cho bản sao khi tham gia. Nếu nó kết quả trong mã đơn giản hơn, hãy làm điều đó, nhưng đừng nghĩ rằng bạn đang lưu bất kỳ bộ nhớ nào.

Answer 5

tôi sẽ đi mảng/join cách:

push(@array, $crunched_bit) 

Và sau đó $str = join('', @array), nếu không có gì hơn, để có quyền truy cập vào tất cả các yếu tố để gỡ lỗi tại một số thời gian sau đó.

Answer 6

Tôi không biết cụ thể cách chuỗi Perl được triển khai nhưng dự đoán khá tốt là đó là constant amortized time. Điều này có nghĩa rằng ngay cả khi bạn tìm cách để phân bổ trước cơ hội chuỗi của bạn là thời gian kết hợp nó sẽ tiết kiệm cho tất cả người dùng của tập lệnh sẽ nhỏ hơn thời gian bạn đã yêu cầu this question trên Stack Overflow.