...
use BL::AbonFee;
...
sub process_services {
...
    foreach (@$services) {
        $dbh->begin_work;
        $logger->writeLog(0, "[$$] start service ".(++$scounter)." (id $_)");
        try {
            if ($process_type eq 'postpaid') {
                $fee->process_postpaid(service_id => $_);   
            }
            else {
                $fee->process(service_id => $_);
            }
        } catch BL::AbonFee::Exception::Nomoney with {
            $logger->writeLog(LOG_INFO, "[$$] no money for service $_");
        };
        $dbh->commit;
        $logger->writeLog(LOG_INFO, "[$$] stop service $_");
    }
...
}
...
my @sths;
push @sths, [$dbh->prepare(qq{
    SELECT service_id
    FROM services
    WHERE ((status > 0) OR (status=$bm_status_service{off_freezed}))
      AND reckoning_date IS NOT NULL AND reckoning_date <= NOW()
    ORDER BY $order}
), 'common'];
foreach my $step (@sths) {
    my ($sth, $type) = @$step;
    
    $sth->execute;
    
    my @services;
    while (my $r = $sth->fetchrow_arrayref) {
        push @services, $$r[0];
        next if scalar(@services) < $chunk;
        process_services($fork, $logger, \@services, $type);
    }
    $sth->finish;
    process_services($fork, $logger, \@services, $type) if scalar @services;
    
    $fork->wait_all;
}

package BL::AbonFee;

use base qw(Class::Accessor::Fast);
...
sub new {
    my $class   = shift;
    my (%param) = @_;

    my $self = $class->SUPER::new({@_});
    
    $self->{logger} ||= $self->_init_logger;
    
    # fetch dict     
    tie my %tie, 'BM::DBHash::Scalar', $self->dbh, 'dict', 'dict_id', 'attribute', { bm_class => ['tariffel', 'sm'] };
    my %dict = %tie;
    untie %tie;
    
    $self->dict({%dict});
    
    my %lists = (
        periodic_types        => [qw(bm_periodic_type  periodic_type_id  mnemonic)],
        charge_types          => [qw(bm_charge_type  mnemonic  charge_type_id)],
        service_status        => [qw(bm_status_service  mnemonic status_id)],
        actual_service_status => [qw(bm_actual_status_service  mnemonic  status_id)],
        service_types         => [qw(bm_type type_id mnemonic)],
        #tariffel_types        => [qw(bm_tariffel_type  mnemonic  tariffel_type_id)]
    );
    
    $self->_hash_list($_, @{$lists{$_}}) foreach keys %lists;
    
    foreach (values %{$self->periodic_types}) {
        my $class = 'BL/AbonFee/' . $_ . '.pm';
        eval {
            require $class;
        };
        die "no module defined for periodic type '$_': $@" if $@;
    }
    
    $self->{partner_prc} = BL::Partner->new($self->dbh);
    $self->{periodic_acct} = BL::PeriodicAcct->new(dbh => $self->dbh, logger => $self->logger);
    $self->{counter_prc} = BL::Counter->new($self->dbh);
    
    $self->{radappsrv} = try {
        my $srv = BM::RadiusAppServer->connect($self->dbh);
        $srv->auth;
        return $srv;
    } catch BM::RadiusAppServerException with {};
    
    return $self;
}
sub process {
    my $self = shift;
    $self->prepare_charges(1, @_);
}
...
1;

#

package BL::AbonFee::base;

use base qw(Class::Accessor::Fast);
...
package BL::AbonFee::Exception;
use base 'BM::Exception';

package BL::AbonFee::Exception::Nomoney;
use base 'BL::AbonFee::Exception';

1;

        my $money = $fee->prepare;
        $self->logger->writeLog(LOG_INFO, "[$$] money: $money");
        
        my $ignored_money = 0;
        
        if ($flag && !$is_xc) {
            try {
                $ignored_money += $fee->create;
            } catch BL::AbonFee::Exception::Nomoney with {
                $is_xc = 1;
                $self->logger->writeLog(LOG_DEBUG, "[$$] not enough money but continue for counting total sum");
            };
        }

sub create {
    my $self = shift;

    return 0 unless ($self->check_balance());
    my $ignored_money;

    if ($self->service_immortal || ($self->avail_money >= $self->{money}) || ($self->tariffel_type($self->periodic_acct->tariffel_id()) eq 'off_freezed_fee')) {
        $ignored_money = $self->SUPER::create;
        $self->update_account;
        #$self->update_service($self->cnt_period->next_period_stop_date($self->periodic_acct->period_start));
        $self->update_service($self->periodic_acct->period_stop);
    } else {
        $self->update_service;
        throw BL::AbonFee::Exception::Nomoney($self->{money});
    }
    
    return $ignored_money;
}