# 并行计算 / 任务池

## `fastmap_withconfig(grid_no, func, parms, parmstype, configs)`

声明：function

读取 configs，解析参数信息，调用 fastmap 模型

<!-- tags: 查询 执行 转换 并行计算 网格计算 任务池 -->

| 参数        | 类型   | 说明                                                                                                                                                                  |
| ----------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `grid_no`   | int    | 整型，网格数                                                                                                                                                          |
| `func`      | string | 字符串型或函数指针，要调用网格计算的函数                                                                                                                              |
| `parms`     | array  | 数组，func 的参数列表                                                                                                                                                 |
| `parmstype` | array  | 数组，parms 的对应类型 取值 说明 0\nil 每次调用都是相同的值（默认） 1 按网格数均分，调用的时候直接用子数组 2 按网格数均分，调用执行的时候，对子数组数组元素单个依次取 |
| `configs`   | array  | 字符串下标数组，执行所需的其他配置，设置                                                                                                                              |

返回：int

## `fastpoolmap_withconfig(pool_num, func, parms, parmstype, configs)`

声明：function

fastmap 任务池版接口，调用网格执行 func

<!-- tags: 并发执行 工作池 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数        | 类型   | 说明                                                                                                                                                                  |
| ----------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pool_num`  | int    | 整型，任务池数，默认两个                                                                                                                                              |
| `func`      | string | 字符串型或函数指针，要调用网格计算的函数                                                                                                                              |
| `parms`     | array  | 数组，func 的参数列表                                                                                                                                                 |
| `parmstype` | array  | 数组，parms 的对应类型 取值 说明 0\nil 每次调用都是相同的值（默认） 1 按网格数均分，调用的时候直接用子数组 2 按网格数均分，调用执行的时候，对子数组数组元素单个依次取 |
| `configs`   | array  | 字符串下标数组，执行所需的其他配置，设置                                                                                                                              |

返回：array

### 示例

范例01：.4.1 提取 50 的 5 日涨幅

```tsl
//**********************参数设置***********************//
   N := 5;
   endt := today();
   stocks := getbk("上证50");

//**********************网格模版*********************//
   gridNo := 3;  //网格个数,0：表示只使用本地服务器
   func := FunctionName() + '.tsubbystocks'; //网格函数
   parms := array(N,endt,stocks);
   parmstype := array(0, 0, 1);
   return unit(MultiProc_unit).fastmap(gridNo,func,parms,parmstype);
//***********************子函数**********************//
function tsubbystocks(N, endt,stocks);
begin
   sp_s(pn_date(),endt);
   i := 0;
   ret := array();
 for _,stk in stocks do
   begin
      sp_s(PN_Stock(),stk);
      for j := 0 to N do
      begin
         ret[I,'截止日'] := ref(sp_time(),j);
         ret[i,'代码'] := stk;
         ret[i,'名称'] := stockname(stk);
         ret[I,'涨幅(%)'] := ref(stockzf3(),j);
         i++;
      end
   end;
   return ret;
end;
```

范例02：调用示例

```tsl
//**********************参数设置***********************//
   N := 5;
   endt := today();
   stocks := getbk("上证50");

//**********************网格模版*********************//

   //**********************网格模版*********************//
   gridNo := 3;  //网格个数,0：表示只使用本地服务器
   func := FunctionName() + '.tsubbystock'; //网格函数
   parms := array(N,endt,stocks);
   parmstype := array(0, 0, 2);
   return unit(MultiProc_unit).fastmap(gridNo,func,parms,parmstype);

function tsubbystock(N, endt,stock);
begin
   sp_s(PN_Stock(),stock);
   sp_s(pn_date(),endt);
   ret := array(
      "代码":stock,
      "名称":stockname(stock),
      "截止日":endt,
      );
   for i := 1 to N do
      ret["T_" $ i] := ref(stockzf3(),i);
   return ret;





end;
```

范例03：调用示例

```tsl
N := 5;
   endt := today();
   stocks := getbk("上证50");

//-------------------------==进程池模板==----------------------------
   poolNum := 2;  //进程池数,默认为2
   func := FunctionName() + '.tsubbystocks'; //网格函数
   parms := array(N,endt,stocks);
   parmstype := array(0, 0, 1);
   configs := array("结果拼接方式":0,'任务单元数':3);

   return unit(MultiProc_unit).fastpoolmap_withconfig(poolNum, func,
parms,parmstype,configs);
//-------------------------==子函数==----------------------------
function tsubbystocks(N, endt,stocks);
begin
   sp_s(pn_date(),endt);
   i := 0;
   ret := array();
 for _,stk in stocks do
   begin
      sp_s(PN_Stock(),stk);
      for j := 0 to N-1 do
      begin
         ret[I,'截止日'] := ref(sp_time(),j);
         ret[i,'代码'] := stk;
         ret[i,'名称'] := stockname(stk);
         ret[I,'涨幅(%)'] := ref(stockzf3(),j);
         i++;
      end





   end;
   return ret;
end;
```

## `gridLogo(str, dir)`

声明：function

网格写日志，一个网格 id 一个文件

<!-- tags: 文件系统 文档文件 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数  | 类型   | 说明                                               |
| ----- | ------ | -------------------------------------------------- |
| `str` | string | 字符串型，任务名称                                 |
| `dir` | string | 字符串型，日志文件路径 ，默认为：C:\\temp\\Gridlog |

返回：int

### 示例

范例01：调用示例

```tsl
//在C:\\temp\\Gridlog 默认路径下写日志文件
Return unit(MultiProc_unit).gridLogo('测试');
```

## `splitDiv(len, n)`

声明：function

网格参数划分，分不平均时，余数给最后一个网格

<!-- tags: 拆分 分割 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数  | 类型 | 说明                              |
| ----- | ---- | --------------------------------- |
| `len` | int  | 整型，参数个数 N_：整型，网格个数 |
| `n`   | int  | 分组或移动窗口的期数/数量         |

返回：array

### 示例

范例01：调用示例

```tsl
Return unit(MultiProc_unit).splitDiv(14,5); // array(0,2,4,6,8,14)
```

## `splitDiv2(len, n)`

声明：function

网格参数划分，分不平均时，前面 M 个网格加一

<!-- tags: 拆分 分割 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数  | 类型 | 说明                              |
| ----- | ---- | --------------------------------- |
| `len` | int  | 整型，参数长度 N_：整型，网格个数 |
| `n`   | int  | 分组或移动窗口的期数/数量         |

返回：array

### 示例

范例01：调用示例

```tsl
Return unit(MultiProc_unit).splitDiv2(14,5); // array(0,3,6,9,12,14)
```

## `splitArrayQK(arr, n)`

声明：function

数组等分区间，余数给最后一个网格

<!-- tags: 拆分 分割 列表 集合 分布式计算 并行执行 并行计算 网格计算 -->

| 参数  | 类型  | 说明                                |
| ----- | ----- | ----------------------------------- |
| `arr` | array | 数组，要划分数组 N_：整型，网格个数 |
| `n`   | int   | 分组或移动窗口的期数/数量           |

返回：array

### 示例

范例01：调用示例

```tsl
arr := array(2,1,3,4,9,5,7,8,9,10,11,12,13,15);




return unit(MultiProc_unit).SplitArrayQK(arr,5);
//array((2,1),(3,4),(9,5),(7,8),(9,15))
```

## `splitArrayQK2(arr, n)`

声明：function

数组等分区间，分不平均时，前面 M 个网格加一

<!-- tags: 拆分 分割 列表 集合 分布式计算 并行执行 并行计算 网格计算 -->

| 参数  | 类型  | 说明                                |
| ----- | ----- | ----------------------------------- |
| `arr` | array | 数组，要划分数组 N_：整型，网格个数 |
| `n`   | int   | 分组或移动窗口的期数/数量           |

返回：array

### 示例

范例01：调用示例

```tsl
arr := array(2,1,3,4,9,5,7,8,9,10,11,12,13,15);
return unit(MultiProc_unit).SplitArrayQK2(arr,5);
// array((2,3),(4,5),(7,9),(10,12),(13,15))
```

## `deleteTablebyReg(reg)`

声明：function

通过正则表达式匹配名称，批量删除用户数据

<!-- tags: 清理 并行计算 网格计算 任务池 -->

| 参数  | 类型   | 说明                   |
| ----- | ------ | ---------------------- |
| `reg` | string | 字符串型，匹配的字符串 |

返回：int

### 示例

范例01：调用示例

```tsl
Return unit(MultiProc_unit).DeleteTablebyReg('test');
```

## `gettablebyReg(reg)`

声明：function

通过正则表达式匹配名称，获取用户数据

<!-- tags: 查询 并行计算 网格计算 任务池 -->

| 参数  | 类型   | 说明                   |
| ----- | ------ | ---------------------- |
| `reg` | string | 字符串型，匹配的字符串 |

返回：array

### 示例

范例01：调用示例

```tsl
Return unit(MultiProc_unit).GettablebyReg('test');
```

## `tryInsetTable(path, value)`

声明：function

添加用户数据，如果用户数据存在同名，则插入，否则新建

<!-- tags: 创建 表数据 二维表 并行计算 网格计算 任务池 -->

| 参数    | 类型   | 说明                       |
| ------- | ------ | -------------------------- |
| `path`  | string | 字符串型，用户数据存储路径 |
| `value` | array  | 数组，要存储的数据         |

返回：int

### 示例

范例01：调用示例

```tsl
Return unit(MultiProc_unit).TryInsetTable('test',array(1,2,3));
```

## `create(grid_num, name, funafter)`

声明：function

初始化

<!-- tags: 创建 并行计算 网格计算 任务池 -->

| 参数       | 类型    | 说明                                                       |
| ---------- | ------- | ---------------------------------------------------------- |
| `grid_num` | integer | 整数，网格数，可不给，与类属性 GridNum 一致                |
| `name`     | string  | 字符串，名称，可不给，与类属性 name 一致                   |
| `funafter` | string  | 字符串，回调模型，可不给，不给时回调模型走类方法 fun_after |

返回：any

## `fun_after(state, ret, param)`

声明：function

执行完之后的自动回调，可重写，主方法自动调用，如果初始化时设置了funafter 参数，则优

<!-- tags: 配置 事件处理 并行计算 网格计算 任务池 -->

| 参数    | 类型    | 说明                                                                                                         |
| ------- | ------- | ------------------------------------------------------------------------------------------------------------ |
| `state` | integer | 整数或字符串，此次调用的执行状态，报错则为报错信息串 -1：未启动 0：已顺利计算完 1：正在计算 字符串：报错信息 |
| `ret`   | array   | 此次调用的执行结果                                                                                           |
| `param` | array   | 此次调用的参数                                                                                               |

返回：any

## `fun_afterwithinfo(state, ret, param, info)`

声明：function

执行完之后的自动回调，有信息列是将信息列与执行结果合并，可重写，主方法自动调用

<!-- tags: 组合 事件处理 并行计算 网格计算 任务池 -->

| 参数    | 类型    | 说明                                                                                                         |
| ------- | ------- | ------------------------------------------------------------------------------------------------------------ |
| `state` | integer | 整数或字符串，此次调用的执行状态，报错则为报错信息串 -1：未启动 0：已顺利计算完 1：正在计算 字符串：报错信息 |
| `ret`   | array   | 此次调用的执行结果                                                                                           |
| `param` | array   | 此次调用的参数                                                                                               |
| `info`  | any     | 信息列                                                                                                       |

返回：any

## `get_result(contype)`

声明：function

回收各进程池的计算结果，如果有信息列则合并在结果中

<!-- tags: 查询 组合 并行计算 网格计算 任务池 -->

| 参数      | 类型 | 说明               |
| --------- | ---- | ------------------ |
| `contype` | any  | 结果合并或返回方式 |

返回：any

## `get_runsummary(ifsuccess, ifallfileds)`

声明：function

执行报告

<!-- tags: 查询 调用 并行计算 网格计算 任务池 -->

| 参数          | 类型 | 说明                                                                       |
| ------------- | ---- | -------------------------------------------------------------------------- |
| `ifsuccess`   | any  | 整型，执行报告处理                                                         |
| `ifallfileds` | any  | 整型，返回字段处理，默认为 0 取值 说明 0 不返回执行结果字段 1 返回全部字段 |

返回：any

## `joins()`

声明：function

等待所有进程结束

<!-- tags: 阻塞 并行计算 网格计算 任务池 -->

返回：any

## `set_mapfunc(funname, param_1, param_2, arg_4)`

声明：function

添加执行

<!-- tags: 配置 调用 并行计算 网格计算 任务池 -->

| 参数      | 类型 | 说明                            |
| --------- | ---- | ------------------------------- |
| `funname` | any  | 目标函数名称                    |
| `param_1` | any  | 添加执行使用的 `param_1` 输入值 |
| `param_2` | any  | 添加执行使用的 `param_2` 输入值 |
| `arg_4`   | any  | 添加执行使用的 `arg_4` 输入值   |

返回：any

## `set_mapfuncwithinfo(info, funname, param_1, param_2, arg_5)`

声明：function

添加执行，传入信息列

<!-- tags: 配置 调用 并行计算 网格计算 任务池 -->

| 参数      | 类型 | 说明                                        |
| --------- | ---- | ------------------------------------------- |
| `info`    | any  | 与任务结果关联的信息数据                    |
| `funname` | any  | 目标函数名称                                |
| `param_1` | any  | 添加执行，传入信息列使用的 `param_1` 输入值 |
| `param_2` | any  | 添加执行，传入信息列使用的 `param_2` 输入值 |
| `arg_5`   | any  | 添加执行，传入信息列使用的 `arg_5` 输入值   |

返回：any

## `set_resultmapfunc(funname, param_1, param_2, arg_4)`

声明：function

添加执行，储存计算结果

<!-- tags: 配置 调用 并行计算 网格计算 任务池 -->

| 参数      | 类型 | 说明                                          |
| --------- | ---- | --------------------------------------------- |
| `funname` | any  | 目标函数名称                                  |
| `param_1` | any  | 添加执行，储存计算结果使用的 `param_1` 输入值 |
| `param_2` | any  | 添加执行，储存计算结果使用的 `param_2` 输入值 |
| `arg_4`   | any  | 添加执行，储存计算结果使用的 `arg_4` 输入值   |

返回：any

## `set_resultmapfuncwithinfo(info, funname, param_1, param_2, arg_5)`

声明：function

添加执行，传入信息列并储存结果

<!-- tags: 配置 调用 并行计算 网格计算 任务池 -->

| 参数      | 类型 | 说明                                                  |
| --------- | ---- | ----------------------------------------------------- |
| `info`    | any  | 与任务结果关联的信息数据                              |
| `funname` | any  | 目标函数名称                                          |
| `param_1` | any  | 添加执行，传入信息列并储存结果使用的 `param_1` 输入值 |
| `param_2` | any  | 添加执行，传入信息列并储存结果使用的 `param_2` 输入值 |
| `arg_5`   | any  | 添加执行，传入信息列并储存结果使用的 `arg_5` 输入值   |

返回：any

## `waits(tm, maxtimes)`

声明：function

轮训等待可用网格，设置最大轮训次数

<!-- tags: 配置 阻塞 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数       | 类型     | 说明                                                                                                                                                                          |
| ---------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `tm`       | datetime | 间隔时间，默认值为由类属性 default_poll_time 设置(1.5s) maxtimes 为最大轮训次数，默认值为 100000，若轮训次数>maxtimes，则退出等待，返回日志： 等待达到最大次数 maxtimes！！！ |
| `maxtimes` | any      | 允许的最大轮询次数                                                                                                                                                            |

返回：any

## `waits_forever(tm)`

声明：function

轮训等待可用网格，不设置最大轮训次数

<!-- tags: 配置 阻塞 分布式计算 并行执行 并行计算 网格计算 任务池 -->

| 参数 | 类型     | 说明                                                    |
| ---- | -------- | ------------------------------------------------------- |
| `tm` | datetime | 间隔时间，默认值为由类属性 default_poll_time 设置(1.5s) |

返回：any
