标签: dynamic-memory-allocation

我在这个问题中遇到了这段小代码,想知道,

realloc()当指向的内存空间缩小时,该函数是否可以将内存块移动到另一个位置？

int * a = malloc( 10*sizeof(int) );
int * b = realloc( a, 5*sizeof(int) );

如果可能的话,在什么条件下,我可以期望b有一个不同于的地址a吗？

int *p;
while(true)
{
 p = new int;
}

由于内存空间不足,此代码不应该崩溃.我已经尝试打印出p的值,即p的内存地址,它似乎增加但没有崩溃.

为什么会这样？

几天前,我学会了如何从互联网创建2D分配的内存阵列,它完美无缺.要访问数组我们只是简单地使用matrix[i][j],但是有什么方法可以通过使用*符号而不是[]输入以及其他方法来取消引用这个2D数组？

第一个问题解决了我可以使用 *(*(matrix + i) + j)

现在我又得到了另一个问题,最后一段代码就是释放分配的内存(我也是从互联网上获得的),但是我不明白,为什么我不能使用delete [] matrix？

int **matrix;

// dynamically allocate an array
matrix = new int *[row]; 
for (int count = 0; count < row; count++)
{
    matrix[count] = new int[col];
}

// input element for matrix
cout << endl << "Now enter the element for the matrix..."; 
for (int i=0; i < row; i++) 
{
    for (int j=0; j < col; j++)
    {
        cout << endl …

是的,另一种realloc与std::vector问题.我知道你要说什么,我同意,忘记手动内存分配,只需使用一个std::vector.不幸的是,我的教授禁止我使用STL的任何东西进行这项任务.

所以,是的,我有一个动态数组,T我需要它可以调整大小,我不能使用std::vector.我可以回到黑暗时代,malloc与家人一起完成整个事情,但如果我可以使用new那将是非常棒的.

我已经阅读了大量的std::vector帖子,其中每个人都说"不,你不能这样做,使用",但它们都是在2011年8月之前发布的,我希望自C +曙光以来可能有所改变的希望+11.那么告诉我,我是幸运的,还是我必须恢复到C风格的内存分配？

我在C中编写了一个用于各种数学计算的库.其中一些需要一些"划痕"空间 - 用于中间计算的内存.所需空间取决于输入的大小,因此无法静态分配.库通常将被用于执行相同类型的具有相同大小的输入计算的多次迭代,因此我不希望malloc和free用于每个呼叫的库内; 分配足够大的块一次,重新使用它进行所有计算,然后释放它会更有效.

我的预期策略是请求void指向单个内存块的指针,可能具有附带的分配功能.说,像这样:

void *allocateScratch(size_t rows, size_t columns);
void doCalculation(size_t rows, size_t columns, double *data, void *scratch);

这个想法是,如果用户打算进行相同大小的多次计算,他可以使用allocate函数来获取足够大的块,然后使用相同的内存块来执行每个输入的计算.分配功能并不是绝对必要的,但它简化了界面并使将来更容易更改存储要求,而库的每个用户都不需要确切知道需要多少空间.

在许多情况下,我需要的内存块只是一个很大的类型double,没有问题.但在某些情况下,我需要混合数据类型 - 比如一个双打块和一个整数块.我的代码需要是可移植的,并且应符合ANSI标准.我知道可以将void指针转换为任何其他指针类型,但如果我尝试对两种类型使用相同的块,我会关注对齐问题.

所以,具体的例子.说我需要一个3 double秒和5 int秒的块.我可以像这样实现我的功能:

void *allocateScratch(...) {
    return malloc(3 * sizeof(double) + 5 * sizeof(int));
}

void doCalculation(..., void *scratch) {
    double *dblArray = scratch;
    int *intArray = ((unsigned char*)scratch) + 3 * sizeof(double);
}

这合法吗？在这个例子中,对齐可能工作正常,但是如果我将其切换并int首先获取double块而第二个块,那将会改变doubles 的对齐(假设64位双精度和32位整数).有一个更好的方法吗？或者我应该考虑更标准的方法？

我最大的目标如下:

• 如果可能的话,我想使用单个块,这样用户就不必处理多个块或需要更改块数.
• 我希望块是一个有效的块, …

当使用pre预分配时std::string::reserve,我必须明确添加一个用于终止0,以避免重新分配和后续复制？

例如,知道"Hello"长度为5 的字符串将被存储std::string str,我是否必须调用str.reserve(6)？

如果我正确地阅读了标准,那么我认为答案应该是肯定的.因为reserve它说

在reserve()之后,capacity()大于或等于reserve的参数.

并capacity反过来它规定

返回:字符串中已分配存储的大小.

不过,我不熟悉标准中配方的细微之处,我想证实我的怀疑.

我想只允许在我的代码库中使用std :: function,如果它不进行任何分配.

为此我可以编写类似下面的函数的东西,只用它来创建我的函数实例:

template< typename Functor>
std::function<Functor> makeFunction( Functor f)
{
    return std::function<Functor>(std::allocator_arg, DummyAllocator(), f);
}

如果DummyAllocator在运行时被使用,它将断言或抛出.

理想情况下,我想在编译时捕获分配用例.

即

template< typename Functor>
std::function<Functor> makeFunction( Functor f)
{
   static_assert( size needed for function to wrap f < space available in function, 
   "error - function will need to allocate memory");

   return std::function<Functor>(f);
 }

这样的事情可能吗？

我有一个类存储一些传入的实时数据的最新值(大约1.5亿事件/秒).

假设它看起来像这样:

class DataState 
{
    Event latest_event;

  public:
  //pushes event atomically
  void push_event(const Event __restrict__* e);
  //pulls event atomically
  Event pull_event();
};

我需要能够以原子方式推送事件并使用严格的排序保证来拉动它们.现在,我知道我可以使用自旋锁,但鉴于大量事件率(超过1亿/秒)和高度并发性,我更喜欢使用无锁操作.

问题是Event大小为64字节.CMPXCHG64B目前的X86 CPU 没有任何指令(截至2016年8月).因此,如果我使用std::atomic<Event>我必须链接到libatomic使用互联网下的互斥量(太慢).

所以我的解决方案是以原子方式交换指向值的指针.问题是动态内存分配成为这些事件率的瓶颈.所以...我定义了一些我称之为"环分配器"的东西:

/// @brief Lockfree Static short-lived allocator used for a ringbuffer
/// Elements are guaranteed to persist only for "size" calls to get_next()
template<typename T> class RingAllocator {
  T *arena;
  std::atomic_size_t arena_idx;
  const std::size_t arena_size;
 public:
  /// @brief Creates a new RingAllocator
  /// @param size The …

这个问题与此类似，但是没有答案。

我正在尝试在YARN模式下的Spark中启用动态分配。我有11个节点群集，其中包含1个主节点和10个工作节点。我在下面的链接中获取指示：

要在YARN中进行设置：http : //spark.apache.org/docs/latest/running-on-yarn.html#configuring-the-external-shuffle-service

需要在spark-defaults.conf中设置配置变量：https : //spark.apache.org/docs/latest/configuration.html#dynamic-allocation https://spark.apache.org/docs/latest/configuration。 html＃shuffle-行为

我还从下面的链接和其他一些资源中获取了参考：https : //jaceklaskowski.gitbooks.io/mastering-apache-spark/spark-dynamic-allocation.html#spark.dynamicAllocation.testing

这是我正在执行的步骤：

1. 在spark-defaults.conf中设置配置变量。我与动态分配和随机播放服务有关的spark-defaults.conf如下：

   spark.dynamicAllocation.enabled=true
   spark.shuffle.service.enabled=true
   spark.shuffle.service.port=7337
   

   Run Code Online (Sandbox Code Playgroud)

2. 在yarn-site.xml中进行更改

   spark.dynamicAllocation.enabled=true
   spark.shuffle.service.enabled=true
   spark.shuffle.service.port=7337
   

   Run Code Online (Sandbox Code Playgroud)

   所有这些步骤都在所有工作程序节点中复制，即spark-defaults.conf具有上述值，而yarn-site.xml具有这些属性。我已确保所有工作节点中都存在/home/hadoop/spark/common/network-yarn/target/scala-2.11/spark-2.2.2-SNAPSHOT-yarn-shuffle.jar。

3. 然后，我在工作节点和主节点中运行$ SPARK_HOME / sbin / start-shuffle-service.sh。在主节点中，我先使用stop-yarn.sh然后再使用start-yarn.sh重新启动YARN。

4. 然后我正在做YARN node -list -all来查看工作程序节点，但是我看不到任何节点

5. 当我禁用财产时

   <property>
       <name>yarn.nodemanager.aux-services</name>
       <value>spark_shuffle</value>
   </property>
   <property>
       <name>yarn.nodemanager.auxservices.spark_shuffle.class</name>
       <value>org.apache.spark.network.yarn.YarnShuffleService</value>
   </property>
   <property>
       <name>yarn.nodemanager.recovery.enabled</name>
       <value>true</value>
   </property>
   <property>
       <name>yarn.application.classpath</name>
       <value> $HADOOP_MAPRED_HOME/share/hadoop/mapreduce/*,$HADOOP_MAPRED_HOME/share/hadoop/mapreduce/lib/*,$HADOOP_MAPRED_HOME/share/hadoop/common/*,$HADOOP_MAPRED_HOME/share/hadoop/common/lib/*,$HADOOP_MAPRED_HOME/share/hadoop/hdfs/*,$HADOOP_MAPRED_HOME/share/hadoop/hdfs/lib/*,$HADOOP_MAPRED_HOME/share/hadoop/yarn/*,$HADOOP_MAPRED_HOME/share/hadoop/yarn/lib/*,$HADOOP_MAPRED_HOME/share/hadoop/tools/*,$HADOOP_MAPRED_HOME/share/hadoop/tools/lib/*,$HADOOP_MAPRED_HOME/share/hadoop/client/*,$HADOOP_MAPRED_HOME/share/hadoop/client/lib/*,/home/hadoop/spark/common/network-yarn/target/scala-2.11/spark-2.2.2-SNAPSHOT-yarn-shuffle.jar </value>
   </property>
   

   Run Code Online (Sandbox Code Playgroud)

   我可以正常看到所有工作节点，因此似乎洗牌服务未正确配置。

我正在读这本书：“ C von A bis Z”。

有这个例子。

/* ptr14.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Fehler: Funktion gibt die Adresse
 * einer lokalen Variablen zurück. */
/* [ Error: Function returns the address of a
     a local variable. ] */
// ...

/* Möglichkeit2: Speicher vom Heap verwenden */
/* [ Option2: Use memory from the heap ] */
char *test3(void){
   char *buffer = (char *) malloc(10);
   strcpy(buffer, "testwert");
   return buffer;
}

/* Möglichkeit3: Einen Zeiger …