Ignore:
Timestamp:
Jun 12, 2010, 9:07:43 AM (14 years ago)
Author:
ronosman
Message:

Refactor thread management to reduce memory footprint ( pLoader now starts with 60 Mo instead of 90 Mo ).

File:
1 edited

Legend:

Unmodified
Added
Removed

  • extensions/pLoader/trunk/src/Uploader/GUI/App.pm

    r6513 r6522  
    134134
    135135
    136 my @transfer_properties = qw/
    137     transfer_thread
    138     transfer_thread_queue
    139     resize_thread
    140     resize_thread_queue
    141 /;
    142 
    143136my @custom_events = qw/
    144137    resize_start_event
    … …  
    151144__PACKAGE__->mk_accessors(@localized_properties);
    152145__PACKAGE__->mk_accessors(@language_properties);
    153 __PACKAGE__->mk_accessors(@transfer_properties);
    154146__PACKAGE__->mk_accessors(@custom_events);
    155147
    … …  
    206198
    207199
    208 sub cancel_queues {
    209     my ( $self ) = @_;
    210 
    211     $self->cancel_resize;
    212     $self->cancel_transfer;
     200sub cancel_all {
     201    my ( $self ) = @_;
     202
     203    $self->resize_manager->cancel;
     204    $self->transfer_manager->cancel;
    213205}
    214206
    … …  
    217209    my( $self ) = @_;
    218210
    219     $self->stop_resize_manager;
    220     $self->stop_transfer_manager;
     211    $self->resize_manager->stop;
     212    $self->transfer_manager->stop;
    221213    $self->stop_single_instance_server;
    222214    $self->login_dlg->Destroy;   
    … …  
    224216
    225217
    226 }
    227 
    228 
    229 sub stop_queues {
    230     my ( $self ) = @_;
    231 
    232     $self->stop_resize;
    233     $self->stop_transfer;
    234 }
    235 
    236 
    237 sub stop_resize_manager {
    238     my( $self ) = @_;
    239 
    240     $self->stop_resize;
    241     $self->resize_thread->detach;
    242 }
    243 
    244 
    245 sub stop_transfer_manager {
    246     my( $self ) = @_;
    247 
    248     $self->stop_transfer;
    249     $self->transfer_thread->detach;
    250 }
    251 
    252 sub cancel_transfer {
    253     my( $self ) = @_;
    254    
    255     my $data : shared = "CANCEL";
    256 
    257     $self->transfer_thread_queue->insert(0, $data);
    258 }
    259 
    260 
    261 sub stop_transfer {
    262     my( $self ) = @_;
    263    
    264     my $data : shared = "STOP";
    265 
    266     $self->transfer_thread_queue->insert(0, $data);
    267218}
    268219
    … …  
    759710    $self->resize_manager(
    760711        Uploader::ResizeManager->new({
    761             site_thumb_dir   => $self->thumb_dir,
    762             wx_thumb_dir     => $self->wx_thumb_dir,
    763             site_resized_dir => $self->resized_dir,
    764             preferences      => sub { $self->preferences(@_) },
    765             write_type       => 'jpg',
     712            thumb_dir      => $self->thumb_dir,
     713            wx_thumb_dir   => $self->wx_thumb_dir,
     714            resized_dir    => $self->resized_dir,
     715            preferences    => sub { $self->preferences(@_) },
     716            progress_event => $resize_progress_event,
     717            done_event     => $resize_done_event,
     718            event_handler  => $self,
    766719        })
    767720    );
    768721
    769     $self->init_resize_thread_queue;
    770722    $self->init_resize_done_event_handler;
    771723    $self->init_resize_progress_event_handler;
    772 }
    773 
    774 
    775 sub init_resize_thread_queue {
    776     my ( $self ) = @_;
    777 
    778     $self->resize_thread_queue(
    779         Thread::Queue->new()
    780     );
    781 
    782     # resize worker starts when receiving data from the resize queue
    783     # resize data must be sent to the calling $handler because $handler data
    784     # cannot be updated inside the thread
    785     $self->resize_thread(
    786         $self->new_resize_thread
    787     );
    788 
    789 }
    790 
    791 
    792 sub new_resize_thread {
    793     my ( $self ) = @_;
    794 
    795     threads->create(
    796         sub {
    797             my ( $handler, $resize_manager, $queue ) = @_;
    798             while (my $data = $queue->dequeue ) {
    799                
    800                 return 1 if 'STOP' eq $data;
    801                 if('CANCEL' eq $data){
    802                     # remove pending
    803                     while($queue->pending){
    804                         # must check if valid $image hash
    805                         $resize_manager->cancel_image(
    806                             $queue->dequeue
    807                         );
    808                     }
    809                 }
    810                 else{
    811                     $resize_manager->process_image(
    812                         $handler,
    813                         $resize_progress_event,
    814                         $resize_done_event,
    815                         $data
    816                     );
    817                 }
    818             }
    819             printf("resize queue %s\n", $queue->pending);
    820         },
    821         $self,
    822         $self->resize_manager,
    823         $self->resize_thread_queue
    824     );
    825 
    826724}
    827725
    … …  
    836734        sub {
    837735            my ( $handler, $event ) = @_;
    838             my $data : shared = shared_clone($event->GetData);
    839             $handler->on_image_progress($data);
     736            my $image : shared = shared_clone($event->GetData);
     737            $handler->on_image_progress($image);
    840738            # image is prepared, send to transfer queue
    841             $self->transfer_thread_queue->enqueue($data);
     739            $self->transfer_manager->add_images([ $image ]);
    842740        }
    843741    );
    … …  
    1077975
    1078976    my $app = {
    1079         site_thumb_dir   => $self->thumb_dir,
     977        thumb_dir   => $self->thumb_dir,
    1080978        wx_thumb_dir     => $self->wx_thumb_dir,
    1081         site_resized_dir => $self->resized_dir,
     979        resized_dir => $self->resized_dir,
    1082980        userdata_dir     => $self->userdata_dir,
    1083981        version          => $self->version,
    … …  
    11071005    }
    11081006    else {
    1109         $self->stop_resize_manager;
     1007        $self->resize_manager->stop;
    11101008        $self->stop_single_instance_server;
    11111009    }
    … …  
    12831181    $self->transfer_manager(
    12841182        Uploader::TransferManager->new({
    1285             site_thumb_dir   => $self->thumb_dir,
    1286             site_resized_dir => $self->resized_dir,
    1287             pwg              => $self->pwg,
     1183            pwg            => $self->pwg,
     1184            progress_event => $transfer_progress_event,
     1185            done_event     => $transfer_done_event,
     1186            event_handler  => $self,
    12881187        })
    12891188    );
    … …  
    12921191        $image_progress_event
    12931192    );
    1294     $self->init_transfer_thread_queue;
     1193
    12951194    $self->init_transfer_done_event_handler;
    12961195    $self->init_transfer_progress_event_handler;
    … …  
    13141213
    13151214
    1316 sub init_transfer_thread_queue {
    1317     my ( $self ) = @_;
    1318 
    1319     $self->transfer_thread_queue(
    1320         Thread::Queue->new()
    1321     );
    1322 
    1323     # transfer worker starts when receiving data from the queue
    1324     # transfer data must be sent to the calling $handler because $handler data
    1325     # cannot be updated inside the thread
    1326     $self->transfer_thread(
    1327         $self->new_transfer_thread
    1328     );
    1329 
    1330 }
    1331 
    1332 
    1333 sub new_transfer_thread {
    1334     my ( $self ) = @_;
    1335 
    1336     threads->create(
    1337         sub {
    1338             my ( $handler, $transfer_manager, $queue ) = @_;
    1339             while (my $data = $queue->dequeue ) {
    1340                 return 1 if 'STOP' eq $data;
    1341                 if('CANCEL' eq $data){
    1342                     while($queue->pending){
    1343                         $transfer_manager->cancel_image(
    1344                             $queue->dequeue
    1345                         );
    1346                     }
    1347                 }
    1348                 else{
    1349                     $transfer_manager->process_image(
    1350                         $handler,
    1351                         $transfer_progress_event,
    1352                         $transfer_done_event,
    1353                         $data
    1354                     );
    1355                 }
    1356             }
    1357             printf("transfer queue %s\n", $queue->pending);
    1358         },
    1359         $self,
    1360         $self->transfer_manager,
    1361         $self->transfer_thread_queue
    1362     );
    1363 
    1364 }
    13651215
    13661216
    … …  
    13991249
    14001250
    1401 sub start_transfer {
    1402     my( $self, $images ) = @_;
    1403    
    1404     my $data : shared = shared_clone($images);
    1405 
    1406     $self->transfer_thread_queue->enqueue($data);
    1407 }
    1408 
    1409 
    14101251sub start_resize {
    14111252    my( $self, $all_images ) = @_;
    … …  
    14171258        $all_images
    14181259    );
    1419     printf("resize thread %s\n", $self->resize_thread);
    1420     $self->resize_thread_queue->enqueue(
    1421         map { shared_clone($_) }@$images
    1422     );
     1260
     1261    $self->resize_manager->add_images($images);
    14231262
    14241263    Wx::PostEvent(
    … …  
    14351274
    14361275
    1437 sub stop_resize {
    1438     my( $self ) = @_;
    1439    
    1440     my $data : shared = "STOP";
    1441 
    1442     $self->resize_thread_queue->insert(0,$data);
    1443 }
    1444 
    1445 
    14461276sub cancel_resize {
    14471277    my( $self ) = @_;
    1448    
    1449     my $data : shared = "CANCEL";
    14501278
    14511279    #
    1452     if( $self->resize_thread_queue->pending and wxYES == Wx::MessageBox(
     1280    if( $self->resize_manager->pending and wxYES == Wx::MessageBox(
    14531281        sprintf(
    14541282            "Cancel %s pending job(s) ?",
    1455             $self->resize_thread_queue->pending,
     1283            $self->resize_manager->pending,
    14561284        ),
    14571285        "pLoader job processing",
    14581286        wxYES_NO|wxNO_DEFAULT| wxICON_QUESTION, )
    14591287    ){
    1460         $self->resize_thread_queue->insert(0,$data);
     1288        $self->resize_manager->cancel;
    14611289    }
    14621290}
Note: See TracChangeset for help on using the changeset viewer.