Howdy Shreyak, welcome to the Monastery! Could you be a bit more specific, perhaps? In particular: could you share some code that demonstrates what you're trying to do, and tell us what error message you are receiving?

Here's some helpful nodes on how to ask questions to get you started:

• On asking for help
• How do I post a question effectively?
• How do I compose an effective node title?
• I know what I mean. Why don't you?
• How (Not) To Ask A Question
• Clean your room
• XY Problem
• The SSCCE: Short, Self Contained, Correct (Compilable) Example

You'll make it so much easier for us to help you.

eval{
open(MSGFILE,'/dir') or die("Cannot open dir");
while (<MSGFILE>)
{
      next if ($_ =~ m/header/i);
      $msg = $_;
      $counter += 1;
      my $getmessage = MQSeries::Message->new;
      $getmessage->Data($msg);
      $dstqobj->Put(Message => $getmessage , Sync => 1) or    $logger-
+>logdie("Unable to put message onto Queue at line  $counter\nCompCode
+ = " . $dstqobj->CompCode() . 
"\nReason = " . $dstqobj->Reason() . "\n");
}
        close MSGFILE;
};
if($@){
      $qmgr->Backout() or $logger->logdie("error in backout: $@");
}
else{
      $qmgr->Commit() or $logger->logdie("error in commiting messages 
+$!");
}
[download]

I've put auto commit option off

I suggest that you modify your approach.   You are most likely running into an architectural “big enough” limit, and it is probably going to be necessary for you to commit smaller batches.   The logic on the receiving end would have to understand that the mere receipt of a particular block of messages does not necessarily mean that the transmission is complete.   Instead, you would need to devise a message that corresponds to the radio-operator’s familiar, “over...”   For instance, ten blocks of 1,000 messages each, then, “over ...”   The receiver would have to have a place (aside from the queue) in which to buffer the received stream until it finally received “over...”

To answer a private-messaged question:

What you are doing here is eliminating any issues imposed by the architectural limits of the queue.   Send units of work across the wire in chunks of convenient and sensible size.   Accumulate them all.   When the receiver hears “over,” it acts upon them as a single atomic unit-of-work.   (And, say, if it hears “forget that,” instead, then it throws-away what it had heard and ignores it, as instructed.)

Don’t let the messages be “unduly large,” such that this conversation becomes a “million-pound elephant” for the queueing infrastructure.   Just send reasonably-sized chunks, as many as may be necessary.