标签: batch-processing

我注意到以下行为.

我有一个大约3MB的文件,包含几千行.在我拆分的行中并创建预备语句(大约250 000条语句).

我所做的是:

preparedStatement
addBatch
do for every 200 rows {
 executeBatch
 clearBatch().
}

在末尾

commit()

没有内存不足错误,内存使用量将增加到70mb左右.是否有可能降低内存使用率？并且具有事务行为(如果一个失败则全部失败.).我能够通过使用executeBatch和提交来降低内存clearBatch...但这会导致整个集合的部分插入.

我们有一个包含2个JBOSS节点的集群.我们有一个批处理作业,它将所有用户详细信息从活动目录加载到数据库.这项工作每天都在运行.它之前在非集群环境中运行,因此我们将其设计为单例.现在我们有一个集群环境,我不知道什么是实现相同结果的最佳方法.我希望批处理作业每天只运行一次.我们使用spring和hibernate,然后看了Spring批处理.我无法对我的问题得到任何简明的答案.

如果你在集群环境中实现批处理,请问有谁可以告诉我吗？在这种情况下,最好的解决方案是什么？

我正在为Emacs开发一个软件项目,它有一些可以批处理模式运行的测试,用于快速回归测试.但是,当测试失败时,终端中的堆栈跟踪会在顶部被切断,因此我必须在交互式Emacs会话中再次运行失败测试,​​以查看完整堆栈恍惚状态并找出错误实际发生的位置.是否有一些我可以修改的变量将扩展Emacs以批处理模式打印到终端的堆栈跟踪的最大长度？

如果你想要一个简单的测试用例来产生一个非常深的堆栈跟踪,这将是一个无限递归的简单案例,当emacs到达某个深度时它会中止:

emacs -Q -batch --eval '(defun f () (f))' -f toggle-debug-on-error -f f

以下是我的系统上该命令的确切输出:

Debug on Error enabled globally
...
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  f()
  command-line-1(("--eval" "(defun f () (f))" "-f" "toggle-debug-on-error" "-f" "f"))
  command-line()
  normal-top-level()

特别要注意的是,后面的行Debug on Error enabled globally实际上是输出中的省略号,如果不以交互方式运行,就无法更深入地进入堆栈跟踪.

我正在尝试使用Google Directory API编写一个为数千名用户创建邮件帐户的应用程序.逐个创建它们有效,但速度极慢.我尝试使用批处理请求,假设一次最多支持1000个请求.但是,只有大约50个用户成功创建,其余请求抛出403错误.如果我将批量大小更改为40,则在第一批之后,许多请求会因5xx错误而失败.

如果批量请求仍然受到相同速率限制的限制,那么似乎毫无价值,因为我可以以这么慢的速率单独发送这些请求.有没有更好的方法来做到这一点还是我应该做的其他事情呢？

我们有bash脚本(作业包装器)写入文件,启动作业,然后在作业完成时,它附加到有关作业的文件信息.包装器在几千个批处理节点中的一个上运行,但只有多个批处理机器(我相信RHEL6)访问一个NFS服务器,并且至少有一个已知的不同批处理作业的实例使用不同的批处理节点NFS服务器.在所有情况下,只有一个客户端主机正在写入相关文件.有些工作需要数小时才能运行,有些则需要几分钟

在发生这种情况的同一时期,100,000多个工作岗位中似乎有10-50个问题.

以下是我认为有效的作业包装器的(蒸馏)版本:

#!/bin/bash
## cwd is /nfs/path/to/jobwd
## This file is /nfs/path/to/jobwd/job_wrapper

gotEXIT()
{
    ## end of script, however gotEXIT is called because we trap EXIT
    END="EndTime: `date`\nStatus: Ended”
    echo -e "${END}" >> job_info
    cat job_info | sendmail jobtracker@example.com
}
trap gotEXIT EXIT

function jobSetVar { echo "job.$1: $2" >> job_info; }
export -f jobSetVar

MSG=“${email_metadata}\n${job_metadata}”
echo -e "${MSG}\nStatus: Started" | sendmail jobtracker@example.com
echo -e "${MSG}" > job_info

## At the job’s end, the output from `time` command is …

我想批量处理大量记录（> 400k）并将其插入数据库中。

我知道如何使用for（）或underscore.each（）遍历数组，而且我知道如何异步地将记录插入各种（无）SQL数据库。那不是问题-问题是我找不到同时做这两种方法的方法。

数据库分发本身在这里不起作用，该原理适用于任何具有异步接口的（NO）SQL数据库。

我正在寻找一种模式来解决以下问题：

循环方法：

var results = []; //imagine 100k objects here
_.each(results,function(row){
  var newObj = prepareMyData(row);

  db.InsertQuery(newObj,function(err,response) {
    if(!err) console.log('YAY, inserted successfully');
  });

});

这种方法显然是有缺陷的。它有点用插入查询来锤击数据库，而不必等待单个查询完成。说到使用连接池的MySQL适配器，您很快就会用尽连接，脚本将失败。

递归方法：

var results = []; //again, full of BIGDATA ;)
var index = 0;
var myRecursion = function()
{
  var row = results[index];
  var data = prepareMyData(row);
  db.InsertQuery(data,function(err, response)
  {
    if (!err)
    {

    console.log('YAY, inserted successfully!');
    index++; //increment for the next recursive call of:
    if (index < results.length) myRecursion();
    }
  }
} …

有时我想以批处理模式运行emacs,在这种情况下我想避免在我的init中做某些事情,比如启动emacs服务器.有没有办法在Emacs Lisp中测试Emacs是否以批处理模式运行？

我正在node.js中读取一个文件(300,000行).我想将5,000行的批量发送到另一个应用程序(Elasticsearch)来存储它们.因此,每当我读完5,000行时,我想通过API将它们批量发送到Elasticsearch来存储它们,然后继续读取文件的其余部分并批量发送每5,000行.

如果我想使用java(或任何其他阻塞语言,如C,C++,python等)来执行此任务,我将执行以下操作:

int countLines = 0;
String bulkString = "";
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("filePath.txt")));
while ((currentLine = br.readLine()) != null) {
     countLines++;
     bulkString += currentLine;
     if(countLines >= 5000){
          //send bulkString to Elasticsearch via APIs
          countLines = 0;
          bulkString = "";
     }
}

如果我想用node.js做同样的事情,我会这样做:

var countLines = 0;
var bulkString = "";
var instream = fs.createReadStream('filePath.txt');
var rl = readline.createInterface(instream, outstream);
rl.on('line', function(line) {
     if(countLines >= 5000){
          //send bulkString to via APIs
          client.bulk({
          index: 'indexName',
          type: 'type',
          body: …

我已经在项目中实施了Hangfire。现在，我需要排队多个工作，这些工作从技术上讲是批处理的一部分。公司不会购买可提供批处理功能的专业版Hangfire。我有什么变通办法可以告诉我所有相关作业何时完成，以便我可以在每个批处理的最后调用另一个函数吗？

例：

Batch A:
{
  BackgroundJob.Enqueue(jobA1);
  BackgroundJob.Enqueue(jobA2);
  BackgroundJob.Enqueue(jobA3);
}

When Batch A is all done: 
  BackgroundJob.Enqueue(createReportForBatchA);

Batch B:
{
  BackgroundJob.Enqueue(jobB1);
  BackgroundJob.Enqueue(jobB2);
  BackgroundJob.Enqueue(jobB3);
}

When Batch B is all done: 
  BackgroundJob.Enqueue(createReportForBatchB);

我唯一能想到的是为批处理中的每个作业设置一个标记“完成”，并在批处理中的每个作业结束时通过检查表中所有与批处理相关的行的标记来检查所有作业是否都已完成。因此将createReportForBatch排队。这样做似乎有点骇人听闻，然后我不得不提出一个问题，我可以将一个后台作业放入另一个BackgroundJob（基本上嵌套）中吗？感谢您的任何意见或建议。

我正在尝试提交一个依赖于阵列完成的扭矩作业.

FIRST=`qsub -q hep -t 1-5 foo.sh`
qsub -q hep -W depend=afterok:$FIRST bar.sh

FIRST作业数组提交并完成正常,但第二个作业bar.sh只是无限期地保留.

如果我从第一个参数中删除数组选项,第二个作业将按计划成功,但这并不能解决问题.

3年前有一个类似的线程,但似乎没有实际解决方案:
如何等待扭矩作业阵列完成

谢谢你的帮助.