标签: resource-management

为什么with-openScala标准库中没有提供ARM(如Clojure )？

什么是C++ 11的一些std::unique_ptr用途和陷阱？

我std::unique_ptr还可以使用它来存储动态分配的数组吗？

我std::unique_ptr可以使用自定义删除机制使用资源吗？

在关于垃圾收集是否是一件好事的神圣战争中,人们经常指出它不处理释放文件句柄之类的事情.将此逻辑放在终结器中被认为是一件坏事,因为资源会被非确定性地释放.然而,似乎一个简单的解决方案是操作系统只需要确保有大量的文件句柄可用,这样它们就是一种廉价而丰富的资源,你可以在任何给定的时间浪费一些.为什么这不是在实践中完成的？

任何人都可以向我提供一个或多个具体的例子,其中RAII 不是最有效的资源管理方法,为什么？

我在YARN集群(HDP 2.4)中使用Spark,具有以下设置:

• 1 Masternode
  • 64 GB RAM(可用50 GB)
  • 24核(可用19核)
• 5 Slavenodes
  • 每个64 GB RAM(可用50 GB)
  • 每个24核(可用19个核)
• YARN设置
  • 所有容器(一个主机)的内存:50 GB
  • 最小容器尺寸= 2 GB
  • 最大容器大小= 50 GB
  • vcores = 19
  • 最小#vcores/container = 1
  • 最大#vcores/container = 19

当我使用命令运行我的spark应用程序时,spark-submit --num-executors 30 --executor-cores 3 --executor-memory 7g --driver-cores 1 --driver-memory 1800m ...YARN使用以下设置创建31个容器(每个执行程序进程一个+一个驱动程序进程):

• 正确:主容器有1个核心和~1800 MB RAM
• 正确:30个从属容器,每个容器约7 GB RAM
• 但是不正确:根据YARN ResourceManager UI(它只显示95个中的31个而不是91 = 30*3 + 1),每个从属容器只运行1个核心而不是3 个核心,请参见下面的截图

我的问题是:为什么spark-submit参数--executor-cores 3没有效果？

我用Java实现AWS Lambda函数并面临问题-如何正确释放已使用的资源？在我的函数中，我对某些资源进行不同的调用：对数据库执行查询、对第三方服务进行 REST 调用（发送 StatsD 指标、调用 Slack webhooks 等）、与 Kinesys 流交互。

不详细说明，我的函数如下所示：

public class RequestHandler {
    private StatisticsService statsService;         //Collect StatsD metrics
    private SlackNotificationService slackService;  //Send Slack notifications
    private SearchService searchService;            //Interact with DB

    //Simplified version of constructor
    public RequestHandler() {
        this.statsService = new StatisticsService();
        this.slackService = new SlackNotificationService();
        this.searchService = new SearchService();
    }

    public LambdaResponse handleRequest(LambdaRequest request, Context context) {
        /**
         * Main method of function
         * where business-logic is executed
         * and all mentioned services are invoked
         */ …

C 中错误中止的最佳实践是什么？

在我们的代码库中，我们目前有一个使用的模式

#define CHECKERROR(code) if(code) { return code; }

但这会导致资源在以下形式的代码中不被关闭

/* not actual code due to non-disclosure restrictions */
int somefunction() {
    handle_t res1, res2;
    int errorcode;

    res1 = getResource();
    res2 = getResource();

    errorcode = action1(res1, res2);
    CHECK(errorcode);
    errorcode = action2(res1, res2);
    CHECK(errorcode);

    freeResource(res1);
    freeResource(res2);
    return errorcode;
}

我发现了这个模式

/* initialize resources */
do {
    /* ... */
    errorcode = action();
    if(errorcode) break;
    /* ... */
} while(0);
/* cleanup resources */
return errorcode;

以前在文章中，但现在找不到任何讨论它的来源。

什么是良好的实践，这对于 C 来说是惯用的？该do …

如果我使用using关键字,我还需要实现IDisposable吗？

我通过将 cpuset 指定为 1 个内核来启动一个 docker 容器：

docker run --cpuset-cpus="0"...

第二个通过将 cpuset 指定为 4 个内核：

docker run --cpuset-cpus="0-3"...

我在每个容器内启动了一个加载进程，并监控了两个容器的 CPU 消耗。

加载过程如下：

ffmpeg input > output

我观察到两个容器之间的执行时间没有改善（没有加速）。

你知道为什么没有改进吗？具有 4 个核心的容器应该比 1 个核心容器运行得更快，对吗？

注意：对 1core 容器使用 top

CPU0%=100%
CPU1%=0
CPU2%=0
CPU3%=0

使用 top 作为 4core 容器，docker 随机选择 4 个内核之一来启动进程。有时它会影响每个核心的 30%

CPU0%=0                  CPU0%=30%                   CPU0%=0
CPU1%=100%       or      CPU0%=30%            or     CPU0%=0
CPU2%=0                  CPU0%=30%                   CPU0%=0
CPU3%=0                  CPU0%=30%                   CPU0%=100%

std::conditional_variable_any 的实现需要（在gcc和clang 中）一个 std::shared_ptr。

在wait方法内部，互斥锁的生命周期将扩展到本地范围。

template<typename _Lock>
  void
  wait(_Lock& __lock)
  {
shared_ptr<mutex> __mutex = _M_mutex; // <-- Extend lifetime of mutex.
unique_lock<mutex> __my_lock(*__mutex);
_Unlock<_Lock> __unlock(__lock);
// *__mutex must be unlocked before re-locking __lock so move
// ownership of *__mutex lock to an object with shorter lifetime.
unique_lock<mutex> __my_lock2(std::move(__my_lock));
_M_cond.wait(__my_lock2);
  }

我想知道，为什么我们需要这个？只要conditional_variable_any对象存在，互斥锁就存在。std::mutex 还不够吗？