标签: multiprocess

我尝试使用C/C++编写程序,在Linux中表现得像top命令.我做了一些研究,并且已经知道如何计算进程的CPU使用率.我们可以通过在当前时间和几秒钟后从/ proc/[PID]/stat计算stime + utime来获得CPU使用率.然后计算stime + utime差异并将结果与​​正常运行时间差异除,然后我们得到CPU使用率百分比.单进程/多线程进程将非常容易.

问题出在类似httpd的情况下,它作为多进程工作.当webserver忙时,httpd将fork子进程来提供一堆请求.然后我计算总进程的数量,比方说500.我想计算这些进程的CPU使用率,但总结它们所以我只看到1个httpd CPU使用率.但是,如果我像上面提到的那样进行算法,当几秒钟后进程数减少到<500时,我得到负值,因为计算将是这样的(例如,我选择随机数,只是为了给你简要说明):

Uptime: 155123, No of processes : 500, Stime + Utime total of 500 processes : 3887481923874
Uptime: 155545, No of processes : 390, Stime + Utime total of 390 processes : 2887123343874

如果您查看上面的示例,Stime + Utime的增量将导致负值,因为进程数减少,并在几毫秒后给出较低的值.我只是想知道,有没有其他方法来计算这样的过程表现如此？谢谢.

我需要磁盘上的键值存储，不要太大或分布不大。用例如下：

• 完整的数据库将只有几个Gbs
• 键和值都具有恒定大小
• 它是一个恒定的数据库。整个数据库写完后，我不需要再写任何条目（或很少写）
• 密钥将以不可预测的顺序访问
• 必须支持多个进程的并发读取。
• 必须非常快，因为读者将紧密地访问数百万个密钥。因此，它应该尽可能像循环遍历关联数组（STL's std::map例如）
• 理想情况下，它应允许设置要使用的RAM数量，通常应使用数百Mb
• 用C或C ++编写。现有的python扩展将是一个很大的优势，但我可以自己添加

因此cdb，gdbm看起来不错的选择，但只是想知道是否有更合适的选择。指向相关基准甚至相关轶事证据的指针将不胜感激。

我遇到了从以下脚本收集日志的问题.一旦我设置SLEEP_TIME为太"小"的值,LoggingThread线程就会以某种方式阻止日志记录模块.该脚本冻结了action函数中的日志记录请求.如果SLEEP_TIME大约为0.1,则脚本会按预期收集所有日志消息.

我试着按照这个答案,但它没有解决我的问题.

import multiprocessing
import threading
import logging
import time

SLEEP_TIME = 0.000001

logger = logging.getLogger()

ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(funcName)s(): %(message)s'))
ch.setLevel(logging.DEBUG)

logger.setLevel(logging.DEBUG)
logger.addHandler(ch)


class LoggingThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        while True:
            logger.debug('LoggingThread: {}'.format(self))
            time.sleep(SLEEP_TIME)


def action(i):
    logger.debug('action: {}'.format(i))


def do_parallel_job():

    processes = multiprocessing.cpu_count()
    pool = multiprocessing.Pool(processes=processes)
    for i in range(20):
        pool.apply_async(action, args=(i,))
    pool.close()
    pool.join()



if __name__ == '__main__':

    logger.debug('START')

    #
    # multithread part
    #
    for _ in range(10): …

我正在使用OpenMP优化一些代码.如果NO_VALUE在一个循环中遇到,我希望它能够打破.但是,编译器告诉我openMP不允许这样做.我怎么能处理这个？

#pragma omp parallel
{
     #pragma omp for  reduction(+:functionEvaluation)   schedule(dynamic)   nowait
     for (int j=m_colStart;j<m_colEnd+1;j++)
          {
               double d = command_->execute().toDouble();
               if(d==NO_VALUE)
               {
                    functionEvaluation  = NO_VALUE;
                                                   break;
                }
                else
                {
                    functionEvaluation += d;
                }
                delete command_;
            }
 }

我该怎么办？谢谢!

我试图读取一个列表,其中包含同步存储在列表中的N个.csv文件.

现在我做以下事情:

导入多进程

1. 空列表
2. 使用.cv的listdir附加列表
3. def A() - 偶数文件(list [:: 2])
4. def B() - 奇数文件(列表[1 :: 2]
5. 流程1 def A()

6. 流程2 def B()

   def read_all_lead_files(folder):
   
       for files in glob.glob(folder+"*.csv"):
           file_list.append(files)
           def read_even():
              file_list[::2]    
           def read_odd():
              file_list[1::2]  
   
        p1 = Process(target=read_even)
        p1.start()
        p2 = Process(target=read_odd)
        p2.start()
   

   Run Code Online (Sandbox Code Playgroud)

有没有更快的方法将列表的分区拆分为Process函数？

进程产生的线程可以在多核系统的不同核心上运行吗？

假设我有一个进程 P，从中生成了两个线程 t1 和 t2，它是一个具有两个核心 C1 和 C2 的多核系统。我的问题是：

1. t1 和 t2 是否可以与进程 P 运行在同一内存空间上？
2. 线程 t1 是否可以在与进程 P 运行的不同内核中执行？例如：进程 P 运行在核心 C1 上，线程 t1 运行在核心 C2 上？

为了研究目的，我用 C++ 开发了一个程序。需要几天时间才能完成。

现在我在我们的实验室 8 核服务器机器上执行它以快速获得结果，但我看到机器只为我的程序分配了一个处理器并且它仍然保持 13% 的处理器使用率（即使我将进程优先级设置为高级别和 8 核亲和力）。

（它是一个简单的面向对象程序，没有任何并行性或多线程）

如何从强大的服务器机器中获得真正的好处？提前致谢。

我无法以编程方式运行多个进程.

这有效......:

PYTHONPATH="/home/developer/Downloads/unittest2-0.5.1:" nosetests --processes=4 

它一次产生4个浏览器.

然而,当在eclipse中运行它时,它会逐个运行它们.

nose.run(defaultTest="",argv=['--processes=4','--verbose', '--process-timeout=30'])

我知道这些论点正在起作用,因为我可以看到与冗长的论点有所区别.

背景：我正在尝试创建一个可由多个进程访问的内存映射文件。在下面的代码中，我只输入了与我目前必须使事情更简单的问题有关的代码。根据msdn，我应该能够创建一个文件映射，映射文件的视图并关闭我从 CreateFileMapping 接收到的句柄，而 MapViewOfFile 将使我的 FileMap 保持活动状态。FileMap 应该仍然可以访问，直到我 UnmapViewOfFile。

MSDN： CreateFileMapping 函数

文件映射对象的映射视图维护对对象的内部引用，并且文件映射对象在对它的所有引用都被释放之前不会关闭。因此，要完全关闭文件映射对象，应用程序必须通过调用 UnmapViewOfFile 取消映射文件映射对象的所有映射视图，并通过调用 CloseHandle 关闭文件映射对象句柄。这些函数可以按任何顺序调用。

问题：成功映射文件视图并关闭 CreateFileMapping 接收到的句柄后，FileMap 不再存在（它应该仍然存在）并且我的 MemMapFileReader 能够创建一个错误为 0 的新映射。（当它应该接收错误 183 '已经存在')

错误的解决方案：不关闭句柄允许它被 MemMapFileReader 程序访问，但会导致 MemMapFileCreator 中的句柄泄漏，因为在进程关闭之前句柄永远不会关闭。

问题：我错过了什么或做错了什么？

内存映射文件创建器

#include "stdafx.h"


#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <tchar.h>
#include <iostream>
#define BUF_SIZE 256
TCHAR szName[] = TEXT("MyFileMappingObject");
TCHAR szMsg[] = TEXT("Message from first process.");

int _tmain()
{
HANDLE hMapFile;
LPCTSTR pBuf;

hMapFile = CreateFileMapping(
    INVALID_HANDLE_VALUE,    // use paging file
    NULL, …

我目前正在尝试使用python多处理.我使用的库是multiprocess(NOT multiprocessing).

我有以下代码,它创建了许多计算作业,并通过映射操作运行它:

pool = multiprocess.Pool(4)
all_responses = pool.map_async(wrapper_singlerun, range(10000))
pool.join()
pool.close()

但是,每当我运行此代码片段时,我都会收到以下错误:

    pool.join()
  File "/Users/davidal/miniconda3/lib/python3.6/site-packages/multiprocess/pool.py", line 509, in join
    assert self._state in (CLOSE, TERMINATE)
AssertionError

你知道为什么会发生这个错误吗？我pool.map_async以前用过,但想到我需要一个pool rendez-vous命令.否则,我的PC创建了类似forkbomb的东西,它创建了太多的线程(至少,这是我认为它做的......)

任何想法都表示赞赏!