• NDArrayPool源代码解析以及测试程序

     NDArrayPool源代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #include 
    13.  
    14. #include 
    15.  
    16. #include "asynNDArrayDriver.h"
    17. #include "NDArray.h"
    18.  
    19. // 在认为一个NDArray对象太大前，它必须比所需的尺寸大多少。
    20. #define THRESHOLD_SIZE_RATIO 1.5
    21.  
    22. static const char *driverName = "NDArrayPool";
    23.  
    24. /*
    25.  * eraseNDAttributes是一个控制每次用NDArrayPool->alloc()分配一个新数组时是否调用NDArray::clearAttributes()的全局标记。
    26.  * 默认值是0，表示clearAttributes()不被调用。这种模式是高效的，因为它节省了大量的分配/接触分配，并且当一旦
    27.  * 为一个驱动设置了这些属性并且不变化时，这是可以的。如果驱动属性被删除，如果这个标记为0，分配的数组将仍然有这些旧的属性，
    28.  * 设置这个标记在每次分配一个的NDArray时强制删除属性。
    29.  */
    30. volatile int eraseNDAttributes=0;
    31. // 导出这个变量到EPICS IOC
    32. extern "C" {epicsExportAddress(int, eraseNDAttributes);}
    33.  
    34. /** NDArrayPool构造器
    35.   * [in] pDriver： 指向创建这个对象的asynNDArrayDriver的指针.
    36.   * [in] maxMemory ： 允许这个池使用的最大内存字节量，所有NDArray对象求和，0=无限
    37.   */
    38. NDArrayPool::NDArrayPool(class asynNDArrayDriver *pDriver, size_t maxMemory)
    39.   : numBuffers_(0), maxMemory_(maxMemory), memorySize_(0), pDriver_(pDriver)
    40. // 初始化时，NDArray对象数目为0，使用内存字节数为0，可用内存最大字节数为传入的maxMemory
    41. {
    42.   listLock_ = epicsMutexCreate(); // 创建互斥量
    43. }
    44.  
    45. /** 创建新的NDArray对象。
    46.   * 这个方法应该被管理派生自NDArray类的对象的池对象重写。
    47.   */
    48. NDArray* NDArrayPool::createArray()
    49. {
    50.     return new NDArray;
    51. }
    52.  
    53. /*
    54.   * 管理派生自NDArray类的对象的池类的hook。
    55.   * 在新的数组已经被分配后，这个hook被调用。
    56.   * [in] pArray： 指向分配的NDArray对象的指针 
    57.   */
    58. void NDArrayPool::onAllocateArray(NDArray *pArray)
    59. {
    60. }
    61.  
    62. /** 管理派生自NDArray类的对象的池类的hook。
    63.   * 在这个数组已经被保留后，这个hook被调用。
    64.   * [in] pArray ： 指向被保留的NDArray对象的指针
    65.   */
    66. void NDArrayPool::onReserveArray(NDArray *pArray)
    67. {
    68. }
    69.  
    70. /** 管理派生自NDArray类的对象的池类的hook。
    71.   * 在这个数组已经被释放后，这个hook被调用。
    72.   * [in] pArray：指向被释放的NDArray对象的指针 
    73.   */
    74. void NDArrayPool::onReleaseArray(NDArray *pArray)
    75. {
    76. }
    77.  
    78.  
    79. /** 分配一个新的NDArray对象，需要前3个参数.
    80.   * [in] ndims：这个NDArray中维度数目.
    81.   * [in] dims ：维度的数组，其尺寸必须至少为ndims.
    82.   * [in] dataType : NDArray的数据类型.
    83.   * [in] dataSize ：为数组数据分配的字节数目 ; 如果0，则alloc将从ndims， 
    84.   * 如果0，则alloc()将从ndims,dims和dataType计算除所需的尺寸。
    85.   * [in] pData : 指向一个数据缓存的指针；如果NULL，则alloc将分配一个新的数组缓存；如果非0，则认为它指向一个有效缓存。
    86.   * 如果pData不是NULL，则dataSize必须包含已有数组中实际的字节数目，并且这个数组必须足够大来保存这些数组数据。
    87.   * alloc()搜索它的空闲列表来查找一个空闲的NDArray缓存。如果不能找到一个空闲的，则它将分配一个新数组
    88.   * 并且添加它到这个空闲列表。如果分配这个NDArray所需的内存将使得为这个池分配的累积内存超过maxMemory，
    89.   * 则将返回一个错误。alloc()设置返回的NDArray的引用计数为1.
    90.   */
    91. NDArray* NDArrayPool::alloc(int ndims, size_t *dims, NDDataType_t dataType, size_t dataSize, void *pData)
    92. {
    93.   NDArray *pArray=NULL;
    94.   NDArrayInfo_t arrayInfo;
    95.   const char* functionName = "NDArrayPool::alloc:";
    96.  
    97.   epicsMutexLock(listLock_);
    98.  
    99.   // 计算所需的NDArray尺寸
    100.   NDArray::computeArrayInfo(ndims, dims, dataType, &arrayInfo); // 根据ndims,dims和dataType获取每个总字节数
    101.   if (dataSize == 0) {
    102.     dataSize = arrayInfo.totalBytes;
    103.   }
    104.  
    105.   std::multiset::iterator pListElement; // freeListElement对象迭代器
    106.   // 传入的数组数据未空，从空闲列表中获取一个
    107.   if (!pData) {
    108.     //  尝试寻找空闲列表中足够大的数组
    109.     freeListElement testElement(NULL, dataSize);
    110.     pListElement = freeList_.lower_bound(testElement); // dataSize为下限的迭代器，调用一次返回一个freeListElement对象
    111.   } else {// 传入的数组数据不为空，则从空闲列表中获取第一个最小的freeListElement对象
    112.     // dataSize没关系, pData将被替代.
    113.     pListElement = freeList_.begin();
    114.   }
    115.  
    116.   if (pListElement == freeList_.end()) {
    117.     /* 我们未找到一个足够大的空闲列表，分配一个新数组 */
    118.     numBuffers_++; //NDArray对象数目加1
    119.     pArray = this->createArray();
    120.   } else {
    121.     pArray = pListElement->pArray_; //到一个足够大的空闲列表，取出这个NDArray对象
    122.     if (pData || (pListElement->dataSize_ > (dataSize * THRESHOLD_SIZE_RATIO))) {
    123.       // 我们找到了一个数组，但它太大。设置这个尺寸为0，因而在下面分配它
    124.       memorySize_ -= pArray->dataSize;
    125.       free(pArray->pData);
    126.       pArray->pData = NULL;
    127.     }
    128.     freeList_.erase(pListElement); //空闲列表从删除这个freeListElement对象
    129.   }
    130.  
    131.   /* 初始化字段：设置这个分配这个NDArray对象的NDArrayPool，引用次数，分配这个NDArray的驱动，数组数据类型，数组数据维度数目 */
    132.   pArray->pNDArrayPool = this;
    133.   pArray->referenceCount = 1;
    134.   pArray->pDriver = pDriver_;
    135.   pArray->dataType = dataType;
    136.   pArray->ndims = ndims;
    137.   // 维度数组置0
    138.   memset(pArray->dims, 0, sizeof(pArray->dims));
    139.   for (int i=0; i
    140.     pArray->dims[i].size = dims[i];
    141.     pArray->dims[i].offset = 0;
    142.     pArray->dims[i].binning = 1;
    143.     pArray->dims[i].reverse = 0;
    144.   }
    145.  
    146.   /* 如果置位了全局标记，删除这些属性 */
    147.   if (eraseNDAttributes) pArray->pAttributeList->clear();
    148.  
    149.   /* 清除codec */
    150.   pArray->codec.clear();
    151.  
    152.   /* 到此，pArray存在，但pArray->pData可能是NULL */
    153.   /* 如果调用者传递一个有效缓存，使用那个缓存 */
    154.   if (pData) {
    155.     pArray->pData = pData;
    156.     pArray->dataSize = dataSize;
    157.     memorySize_ += dataSize;
    158.   } else if (pArray->pData == NULL) {
    159.     if ((maxMemory_ > 0) && ((memorySize_ + dataSize) > maxMemory_)) {
    160.       /*
    161.        * 我们没有分配这个数组的足够内存，看我们是否能通过删除数组获取内存
    162.        * 首先删除最大的数组，及从freeList_末尾开始。       
    163.        */
    164.       NDArray *freeArray;
    165.       std::multiset::iterator it;
    166.       // 已用内存+dataSiz大于可用最大内存量，需要释放数组
    167.       while (!freeList_.empty() && ((memorySize_ + dataSize) > maxMemory_)) {
    168.         it = freeList_.end(); // 获取末尾的freeListElement对象
    169.         it--;
    170.         freeArray = it->pArray_;
    171.         // 从空闲列表中删除获取的freeListElement对象
    172.         freeList_.erase(it);
    173.         // 内存使用量减少获取的freeListElement对象的dataSize
    174.         memorySize_ -= freeArray->dataSize;
    175.         // NDArray对象数目减少1
    176.         numBuffers_--;
    177.         // 释放获取的freeListElement对象
    178.         delete freeArray;
    179.       }
    180.     }
    181.     // 如果最大可用内存量有限制并且已用内存量+dataSize大于最大可用内存量
    182.     if ((maxMemory_ > 0) && ((memorySize_ + dataSize) > maxMemory_)) {
    183.       asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_ERROR,
    184.              "%s: error: reached limit of %ld memory (%d buffers)\n",
    185.              functionName, (long)maxMemory_, numBuffers_);
    186.     } else {
    187.       pArray->pData = malloc(dataSize); // 分配数组数据区
    188.       if (pArray->pData) {//分配成功，设置NDArray的dataSize和
    189.         pArray->dataSize = dataSize; 
    190.         pArray->compressedSize = dataSize;
    191.         memorySize_ += dataSize; // 内存使用量增加dataSize
    192.       }
    193.     }
    194.   }
    195.   // 如果我们没有一个有效内存缓存，设置pArray为NULL来表示错误
    196.   if (pArray && (pArray->pData == NULL)) {
    197.     delete pArray;
    198.     numBuffers_--;
    199.     pArray = NULL;
    200.   }
    201.  
    202.   // 调用分配hook(用于管理派生自NDArray类的对象的池)
    203.   onAllocateArray(pArray);
    204.   epicsMutexUnlock(listLock_);
    205.   return (pArray);
    206. }
    207.  
    208. /** 这个方法复制一个NDArray对象。
    209.   * [in] pIn ：要被复制的输入数组.
    210.   * [in] pOut：将被复制到的输出数组；可以是NULL或者一个指向一个已有NDArray的指针。
    211.   * [in] copyData：如果这个标记为true，则包括数组数据的所有东西都被复制。如果0， 复制除了数据外(包括属性)的所有东西。
    212.   * [in] copyDimensions ：如果这个标记为true， 则即使pOut不为NULL，也复制这些维度；默认为true
    213.   * [in] copyDataType：如果这个标记为true， 即使pOut不为NULL，也复制dataType, 默认为true
    214.   * 返回：返回一个指向输出数组的指针
    215.   *
    216.   * 如果pOut为NULL，首先分配它。如果输出数组对象已经存在(pOut!=NULL)，则必须已经分配足够空间给它来保存数据。
    217.   */
    218. NDArray* NDArrayPool::copy(NDArray *pIn, NDArray *pOut, bool copyData, bool copyDimensions, bool copyDataType)
    219. {
    220.   //const char *functionName = "copy";
    221.   size_t dimSizeOut[ND_ARRAY_MAX_DIMS];
    222.   int i;
    223.   size_t numCopy;
    224.   NDArrayInfo arrayInfo;
    225.  
    226.   /*  如果输出数组不存在，则创建它 */
    227.   if (!pOut) {
    228.     for (i=0; indims; i++) dimSizeOut[i] = pIn->dims[i].size; // 从输入数组的每个维度获取输出数组每个维度尺寸
    229.     pOut = this->alloc(pIn->ndims, dimSizeOut, pIn->dataType, 0, NULL); // 数据类型使用输入数组的数据类型，dataSize取0，则alloc自行计算
    230.     if(NULL==pOut) return NULL;
    231.   }
    232.   // 复制uniqueId, timeStamp，epicsTS 
    233.   pOut->uniqueId = pIn->uniqueId;
    234.   pOut->timeStamp = pIn->timeStamp;
    235.   pOut->epicsTS = pIn->epicsTS;
    236.   // 如果copyDimensions为true，则复制维度数目以及每个维度上的尺寸
    237.   if (copyDimensions) {
    238.     pOut->ndims = pIn->ndims;
    239.     memcpy(pOut->dims, pIn->dims, sizeof(pIn->dims));
    240.   }
    241.   // 如果copyDataType为true，则复制数据类型
    242.   if (copyDataType) {
    243.     pOut->dataType = pIn->dataType;
    244.   }
    245.   // 复制编码算法名
    246.   pOut->codec.name = pIn->codec.name;
    247.   // 复制压缩后的尺寸
    248.   pOut->compressedSize = pIn->compressedSize;
    249.   // 如果copyData为true，
    250.   if (copyData) { // 
    251.     pIn->getInfo(&arrayInfo);
    252.     numCopy = pIn->codec.empty() ? arrayInfo.totalBytes : pIn->compressedSize; // codec.empty()为true，表示没有使用压缩算法
    253.     if (pOut->dataSize < numCopy) numCopy = pOut->dataSize; //需要复制的数据量取数组数据尺寸和输入数组尺寸中的小者
    254.     memcpy(pOut->pData, pIn->pData, numCopy); // 将输入数组中数据区中数据复制到输出数组中数据区
    255.   }
    256.   pOut->pAttributeList->clear(); // 清除输出数组中属性列表中所有属性
    257.   pIn->pAttributeList->copy(pOut->pAttributeList); // 将输入数组中属性列表中所有属性复制到输出数组的属性列表中
    258.   return(pOut);
    259. }
    260.  
    261. /** 这个方法增加这个NDArray对象的引用次数。
    262.   * [in] pArray ：对这个数组增加引用计数.
    263.   * 当一个NDArray被放到一个队列为了之后处理，插件必须调用reserve()。
    264.   */
    265. int NDArrayPool::reserve(NDArray *pArray)
    266. {
    267.   const char *functionName = "reserve";
    268.  
    269.   /* Make sure we own this array 确认我们拥有这个数组 */
    270.   if (pArray->pNDArrayPool != this) {// 这个NDArray对象不是这个NDArrayPool对象分配的
    271.     asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_ERROR,
    272.       "%s::%s: ERROR, not owner!  owner=%p, should be this=%p\n",
    273.       driverName, functionName, pArray->pNDArrayPool, this);
    274.     return(ND_ERROR);
    275.   }
    276.   //asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_FLOW,
    277.   //  "NDArrayPool::reserve pArray=%p, count=%d\n", pArray, pArray->referenceCount);
    278.   epicsMutexLock(listLock_);
    279.   // 如果引用次数少于1，则出问题了，这个NDArray已经被释放了
    280.   if (pArray->referenceCount < 1) {
    281.     cantProceed("%s:reserve ERROR, reference count = %d, should be >= 1, pArray=%p\n",
    282.            driverName, pArray->referenceCount, pArray);
    283.   }
    284.   pArray->referenceCount++; // 传入NDArray对象的引用次数加1
    285.  
    286.   // 调用保留hook(用于管理派生自NDArray类的对象的池)
    287.   onReserveArray(pArray);
    288.   epicsMutexUnlock(listLock_);
    289.   return ND_SUCCESS;
    290. }
    291.  
    292. /** 这个方法减小对NDArray对象的引用次数。
    293.   * [in] pArray ：对这个数组减少引用次数
    294.   * 当引用次数到达0，NDArray被放回空闲列表。
    295.   * 当一个NDArray被从队列移除并且对其处理结束时，插件必须调用release()。
    296.   * 在调用所有插件后，驱动必须调用release()。
    297.   */
    298. int NDArrayPool::release(NDArray *pArray)
    299. {
    300.   const char *functionName = "release";
    301.  
    302.   /* 确认我们拥有这个数组 */
    303.   if (pArray->pNDArrayPool != this) {
    304.     asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_ERROR,
    305.       "%s::%s: ERROR, not owner!  owner=%p, should be this=%p\n",
    306.       driverName, functionName, pArray->pNDArrayPool, this);
    307.     return(ND_ERROR);
    308.   }
    309.   //asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_FLOW,
    310.   //  "NDArrayPool::release pArray=%p, count=%d\n", pArray, pArray->referenceCount);
    311.   epicsMutexLock(listLock_);
    312.   pArray->referenceCount--;// 引用次数减少1
    313.   if (pArray->referenceCount == 0) {// 引用次数为0
    314.     /* The last user has released this image, add it back to the free list 最后的用户释放这个图像，添加它到空闲列表*/
    315.     freeListElement listElement(pArray, pArray->dataSize);
    316.     freeList_.insert(listElement);
    317.   }
    318.   if (pArray->referenceCount < 0) {
    319.     cantProceed("%s:release ERROR, reference count < 0 pArray=%p\n",
    320.            driverName, pArray);
    321.   }
    322.  
    323.   // 调用释放释放hook(用于管理派生自NDArray类的池)
    324.   onReleaseArray(pArray);
    325.   epicsMutexUnlock(listLock_);
    326.   return ND_SUCCESS;
    327. }
    328.  
    329. // 输入数组数据类型和输出数组数据类型之间的转换
    330. template <typename dataTypeIn, typename dataTypeOut> void convertType(NDArray *pIn, NDArray *pOut)
    331. {
    332.   size_t i;
    333.   dataTypeIn *pDataIn = (dataTypeIn *)pIn->pData; // 输入数组的数据区
    334.   dataTypeOut *pDataOut = (dataTypeOut *)pOut->pData; // 输出数组的数据区
    335.   NDArrayInfo_t arrayInfo;
    336.  
    337.   pOut->getInfo(&arrayInfo);
    338.   for (i=0; i
    339.     *pDataOut++ = (dataTypeOut)(*pDataIn++); // 将输入数组中数据类型转成输出数据中数据类型
    340.   }
    341. }
    342.  
    343. //把输入数组数据类型转成输出数组数据类型
    344. template <typename dataTypeOut> int convertTypeSwitch (NDArray *pIn, NDArray *pOut)
    345. {
    346.   int status = ND_SUCCESS;
    347.  
    348.   switch(pIn->dataType) {
    349.     case NDInt8:
    350.       convertType (pIn, pOut);
    351.       break;
    352.     case NDUInt8:
    353.       convertType (pIn, pOut);
    354.       break;
    355.     case NDInt16:
    356.       convertType (pIn, pOut);
    357.       break;
    358.     case NDUInt16:
    359.       convertType (pIn, pOut);
    360.       break;
    361.     case NDInt32:
    362.       convertType (pIn, pOut);
    363.       break;
    364.     case NDUInt32:
    365.       convertType (pIn, pOut);
    366.       break;
    367.     case NDInt64:
    368.       convertType (pIn, pOut);
    369.       break;
    370.     case NDUInt64:
    371.       convertType (pIn, pOut);
    372.       break;
    373.     case NDFloat32:
    374.       convertType (pIn, pOut);
    375.       break;
    376.     case NDFloat64:
    377.       convertType (pIn, pOut);
    378.       break;
    379.     default:
    380.       status = ND_ERROR;
    381.       break;
    382.   }
    383.   return(status);
    384. }
    385.  
    386. /*
    387.     1、当输入和输出数组都是一维数组时，dim = 0
    388.     1 2 3 4 5 6  => 1 2 3
    389. */
    390. template <typename dataTypeIn, typename dataTypeOut> void convertDim(NDArray *pIn, NDArray *pOut,
    391.                                                      void *pDataIn, void *pDataOut, int dim)
    392. {
    393.   dataTypeOut *pDOut = (dataTypeOut *)pDataOut; // 输出数组数据区
    394.   dataTypeIn *pDIn = (dataTypeIn *)pDataIn;     // 输入数组数据区
    395.   /*
    396.     size_t size;   
    397.     size_t offset;                
    398.     int binning;   
    399.     int reverse;
    400. */ 
    401.   NDDimension_t *pOutDims = pOut->dims; // 输出数组的维度数组
    402.   NDDimension_t *pInDims = pIn->dims;    //输入数组的维度数组
    403.   size_t inStep, outStep, inOffset;
    404.   int inDir;
    405.   int i, bin;
    406.   size_t inc, in, out;
    407.  
    408.   inStep = 1;
    409.   outStep = 1;
    410.   inDir = 1;
    411.   inOffset = pOutDims[dim].offset;
    412.   for (i=0; i// 以dim为1为例子，inStep是输入数组元素数目，outStep是输出数组元素数目
    413.     inStep  *= pInDims[i].size;
    414.     outStep *= pOutDims[i].size;
    415.   }
    416.   if (pOutDims[dim].reverse) {// 如果输出数组是反向的，输入数组中要取的最后一个元素的偏移
    417.     inOffset += pOutDims[dim].size * pOutDims[dim].binning - 1;
    418.     inDir = -1; // 表示输入数组反向取
    419.   }
    420.   inc = inDir * inStep;    // 步长
    421.   pDIn += inOffset*inStep; // 输入数组数据区取值起始位置
    422.   for (in=0, out=0; out// 逐个从输入数组中按顺序取数值进行转换放入输出数组数据区
    423.     for (bin=0; bin
    424.       if (dim > 0) {
    425.         convertDim  (pIn, pOut, pDIn, pDOut, dim-1);
    426.       } else {
    427.         *pDOut += (dataTypeOut)*pDIn;
    428.       }
    429.       pDIn += inc;
    430.     }
    431.     pDOut += outStep;
    432.   }
    433. }
    434.  
    435. // 
    436. template <typename dataTypeOut> int convertDimensionSwitch(NDArray *pIn, NDArray *pOut,
    437.                                                            void *pDataIn, void *pDataOut, int dim)
    438. {
    439.   int status = ND_SUCCESS;
    440.  
    441.   switch(pIn->dataType) {
    442.     case NDInt8:
    443.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    444.       break;
    445.     case NDUInt8:
    446.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    447.       break;
    448.     case NDInt16:
    449.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    450.       break;
    451.     case NDUInt16:
    452.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    453.       break;
    454.     case NDInt32:
    455.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    456.       break;
    457.     case NDUInt32:
    458.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    459.       break;
    460.     case NDInt64:
    461.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    462.       break;
    463.     case NDUInt64:
    464.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    465.       break;
    466.     case NDFloat32:
    467.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    468.       break;
    469.     case NDFloat64:
    470.       convertDim  (pIn, pOut, pDataIn, pDataOut, dim);
    471.       break;
    472.     default:
    473.       status = ND_ERROR;
    474.       break;
    475.   }
    476.   return(status);
    477. }
    478.  
    479. static int convertDimension(NDArray *pIn,
    480.                             NDArray *pOut,
    481.                             void *pDataIn,
    482.                             void *pDataOut,
    483.                             int dim)
    484. {
    485.   int status = ND_SUCCESS;
    486.   /* 这个例程被传递：
    487.    * 一个指向输入数据起始位置的指针：
    488.    * 一个指向输出数据起始位置的指针
    489.    * 一个维度的数组
    490.    * 维度索引
    491.    */
    492.   switch(pOut->dataType) {
    493.     case NDInt8:
    494.       convertDimensionSwitch (pIn, pOut, pDataIn, pDataOut, dim);
    495.       break;
    496.     case NDUInt8:
    497.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    498.       break;
    499.     case NDInt16:
    500.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    501.       break;
    502.     case NDUInt16:
    503.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    504.       break;
    505.     case NDInt32:
    506.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    507.       break;
    508.     case NDUInt32:
    509.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    510.       break;
    511.     case NDInt64:
    512.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    513.       break;
    514.     case NDUInt64:
    515.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    516.       break;
    517.     case NDFloat32:
    518.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    519.       break;
    520.     case NDFloat64:
    521.       convertDimensionSwitch  (pIn, pOut, pDataIn, pDataOut, dim);
    522.       break;
    523.     default:
    524.       status = ND_ERROR;
    525.       break;
    526.   }
    527.   return(status);
    528. }
    529.  
    530. /**  从一个输入NDArray创建一个新的输出NDArray，执行转换操作。
    531.   * 这个函数形式用于仅更改数据类型，不是维度，维度被保留。
    532.   * [in] pIn ：输入数组，转换的来源.
    533.   * [out] ppOut ： 输出数组，转换结果。
    534.   * [in] dataTypeOut ：输出数组的数据类型
    535.   */
    536. int NDArrayPool::convert(NDArray *pIn,
    537.                          NDArray **ppOut,
    538.                          NDDataType_t dataTypeOut)
    539.  
    540. {
    541.   NDDimension_t dims[ND_ARRAY_MAX_DIMS];
    542.   int i;
    543.   // 输出数组的维度与输入数组的维度一样
    544.   for (i=0; indims; i++) {
    545.     dims[i].size  = pIn->dims[i].size;
    546.     dims[i].offset  = 0;
    547.     dims[i].binning = 1;
    548.     dims[i].reverse = 0;
    549.   }
    550.   return this->convert(pIn, ppOut, dataTypeOut, dims);
    551. }
    552.  
    553. /** 从一个输入NDArray创建一个新的输出NDArray，执行转换操作。
    554.   * 如果dataTypeout不同于pIn->dataType，转换可以更改数据类型。
    555.   * 它也可以更改维度，outDims其每个维度可以有与输入数组维度(pIn->dims)不同的size，binning，offset和reverse的值。
    556.   * 
    557.   * [in] pIn ：这个输入数组，转换的来源.
    558.   * [out]ppOut：输出数组，转换的结果 
    559.   * [in] dataTypeOut：输出数组的数据类型 
    560.   * [in] dimsOut ：输出数组的维度.
    561.   */
    562. int NDArrayPool::convert(NDArray *pIn,
    563.                          NDArray **ppOut,
    564.                          NDDataType_t dataTypeOut,
    565.                          NDDimension_t *dimsOut)
    566. {
    567.   int dimsUnchanged;
    568.   size_t dimSizeOut[ND_ARRAY_MAX_DIMS];
    569.   NDDimension_t dimsOutCopy[ND_ARRAY_MAX_DIMS];
    570.   int i;
    571.   NDArray *pOut;
    572.   NDArrayInfo_t arrayInfo;
    573.   NDAttribute *pAttribute;
    574.   int colorMode, colorModeMono = NDColorModeMono;
    575.   const char *functionName = "convert";
    576.  
    577.   /* 初始化出错 */
    578.   *ppOut = NULL;
    579.  
    580.   /* 不能转换被压缩的数据 */
    581.   if (!pIn->codec.empty()) {
    582.     fprintf(stderr, "%s:%s: can't convert compressed data [%s]\n",
    583.             driverName, functionName, pIn->codec.name.c_str());
    584.     return ND_ERROR;
    585.   }
    586.  
    587.   /*  因为我们需要修改它，但我们不要影响调用者，复制输入维度数组 */
    588.   memcpy(dimsOutCopy, dimsOut, pIn->ndims*sizeof(NDDimension_t)); // 维度数由输入数组的维度数决定
    589.   /* 计算输出数组的维度  */
    590.   dimsUnchanged = 1;
    591.   for (i=0; indims; i++) {
    592.     dimsOutCopy[i].size = dimsOutCopy[i].size/dimsOutCopy[i].binning; // 输出数组每个维度的尺寸
    593.     if (dimsOutCopy[i].size <= 0) {
    594.       asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_ERROR,
    595.         "%s:%s: ERROR, invalid output dimension, size=%d, binning=%d\n",
    596.         driverName, functionName, (int)dimsOut[i].size, dimsOut[i].binning);
    597.       return(ND_ERROR);
    598.     }
    599.     dimSizeOut[i] = dimsOutCopy[i].size; // 存储输出数组每一维度的尺寸的数组
    600.     if ((pIn->dims[i].size  != dimsOutCopy[i].size) || // 只要满足输出数组每个维度上尺寸与输入输入对那个维度不同
    601.       (dimsOutCopy[i].offset != 0) || // 或者输出数组每个维度上有偏移量或者有binning或者反向了，则输出维度就发生了变化
    602.       (dimsOutCopy[i].binning != 1) ||
    603.       (dimsOutCopy[i].reverse != 0)) dimsUnchanged = 0;
    604.   }
    605.  
    606.   /*  我们知道了输出数组的数据类型和维度，分配它 */
    607.   pOut = alloc(pIn->ndims, dimSizeOut, dataTypeOut, 0, NULL);
    608.   *ppOut = pOut;
    609.   if (!pOut) {
    610.     asynPrint(pDriver_->pasynUserSelf, ASYN_TRACE_ERROR,
    611.       "%s:%s: ERROR, cannot allocate output array\n",
    612.       driverName, functionName);
    613.     return(ND_ERROR);
    614.   }
    615.   /*从输入NDArray对象复制字段到输出NDArray对象  */
    616.   pOut->timeStamp = pIn->timeStamp;
    617.   pOut->epicsTS = pIn->epicsTS;
    618.   pOut->uniqueId = pIn->uniqueId;
    619.   /*  用传递给这个函数的那些维度结构体替换输出NDArray中的dims中存储的维度结构体 */
    620.   memcpy(pOut->dims, dimsOutCopy, pIn->ndims*sizeof(NDDimension_t));
    621.   pIn->pAttributeList->copy(pOut->pAttributeList);
    622.  
    623.   pOut->getInfo(&arrayInfo);
    624.  
    625.   if (dimsUnchanged) {
    626.     if (pIn->dataType == pOut->dataType) {
    627.       /*
    628.        * 维度相同并且数据类型相同，则仅复制输入图像到输出图像。
    629.        */
    630.       memcpy(pOut->pData, pIn->pData, arrayInfo.totalBytes);
    631.       return ND_SUCCESS;
    632.     } else {
    633.       /* 我们需要转换数据类型 */
    634.       switch(pOut->dataType) {// 根据输出NDArray中数据类型，将输入NDArray中数据转成输出NDArray中数据类型
    635.         case NDInt8:
    636.           convertTypeSwitch  (pIn, pOut);
    637.           break;
    638.         case NDUInt8:
    639.           convertTypeSwitch  (pIn, pOut);
    640.           break;
    641.         case NDInt16:
    642.           convertTypeSwitch  (pIn, pOut);
    643.           break;
    644.         case NDUInt16:
    645.           convertTypeSwitch  (pIn, pOut);
    646.           break;
    647.         case NDInt32:
    648.           convertTypeSwitch  (pIn, pOut);
    649.           break;
    650.         case NDUInt32:
    651.           convertTypeSwitch  (pIn, pOut);
    652.           break;
    653.         case NDInt64:
    654.           convertTypeSwitch  (pIn, pOut);
    655.           break;
    656.         case NDUInt64:
    657.           convertTypeSwitch  (pIn, pOut);
    658.           break;
    659.         case NDFloat32:
    660.           convertTypeSwitch  (pIn, pOut);
    661.           break;
    662.         case NDFloat64:
    663.           convertTypeSwitch  (pIn, pOut);
    664.           break;
    665.         default:
    666.           //status = ND_ERROR;
    667.           break;
    668.       }
    669.     }
    670.   } else {
    671.     /* 对整个输出NDArray的数据清零 */
    672.     memset(pOut->pData, 0, arrayInfo.totalBytes);
    673.     convertDimension(pIn, pOut, pIn->pData, pOut->pData, pIn->ndims-1);
    674.   }
    675.  
    676.   /*  设置输出数组中的字段 */
    677.   for (i=0; indims; i++) {
    678.     pOut->dims[i].offset = pIn->dims[i].offset + dimsOutCopy[i].offset;
    679.     pOut->dims[i].binning = pIn->dims[i].binning * dimsOutCopy[i].binning;
    680.     if (pIn->dims[i].reverse) pOut->dims[i].reverse = !pOut->dims[i].reverse;
    681.   }
    682.  
    683.   /* 
    684.    * 如果帧是RGBx帧，并且我们折叠那个维度，则更改颜色模式
    685.    */
    686.   pAttribute = pOut->pAttributeList->find("ColorMode");
    687.   if (pAttribute && pAttribute->getValue(NDAttrInt32, &colorMode)) {
    688.     if      ((colorMode == NDColorModeRGB1) && (pOut->dims[0].size != 3))
    689.       pAttribute->setValue(&colorModeMono);
    690.     else if ((colorMode == NDColorModeRGB2) && (pOut->dims[1].size != 3))
    691.       pAttribute->setValue(&colorModeMono);
    692.     else if ((colorMode == NDColorModeRGB3) && (pOut->dims[2].size != 3))
    693.       pAttribute->setValue(&colorModeMono);
    694.   }
    695.   return ND_SUCCESS;
    696. }
    697.  
    698. /** 返回这个对象当分配的缓存数目 */
    699. int NDArrayPool::getNumBuffers()
    700. {
    701.   return numBuffers_;
    702. }
    703.  
    704. /**  0=unlimited 返回允许这个对象分配的最大内存字节 */
    705. size_t NDArrayPool::getMaxMemory()
    706. {
    707.   return maxMemory_;
    708. }
    709.  
    710. /**  返回这个对象当前已经分配的内存字节数 */
    711. size_t NDArrayPool::getMemorySize()
    712. {
    713.   return memorySize_;
    714. }
    715.  
    716. /** 返回空闲列表中NDArray对象的数目  */
    717. int NDArrayPool::getNumFree()
    718. {
    719.   epicsMutexLock(listLock_);
    720.   int size = (int)freeList_.size();
    721.   epicsMutexUnlock(listLock_);
    722.   return size;
    723. }
    724.  
    725. /**  删除空闲列表中所有NDArrays */
    726. void NDArrayPool::emptyFreeList()
    727. {
    728.   NDArray *freeArray;
    729.   std::multiset::iterator it; // 获取freeListElement对象的迭代器
    730.   epicsMutexLock(listLock_);
    731.   while (!freeList_.empty()) { 
    732.     it = freeList_.begin(); // 获取第一个freeListElement对象
    733.     freeArray = it->pArray_; // 获取NDArray对象
    734.     freeList_.erase(it);  // 从空闲列表中删除
    735.     memorySize_ -= freeArray->dataSize;
    736.     numBuffers_--;
    737.     delete freeArray;
    738.   }
    739.   epicsMutexUnlock(listLock_);
    740. }
    741.  
    742. /** 报告NDArrayPool空闲列表尺寸和其它性质。
    743.   * [in] fp : 报告输出的文件指针
    744.   * [in] details ： 所要报告的详细程度，当前什么也没做.
    745.   */
    746. int NDArrayPool::report(FILE *fp, int details)
    747. {
    748.   fprintf(fp, "\n");
    749.   fprintf(fp, "NDArrayPool:\n");
    750.   fprintf(fp, "  numBuffers=%d, numFree=%d\n",
    751.          numBuffers_, this->getNumFree()); // 缓存数量，还可分配的内存
    752.   fprintf(fp, "  memorySize=%ld, maxMemory=%ld\n",
    753.         (long)memorySize_, (long)maxMemory_); //已用内存数，最大内存分配数量
    754.   if (details > 5) { // 每个NDArray的信息：NDArray序号，NDArray数据区的尺寸，以及NDArray的地址
    755.     int i;
    756.     std::multiset::iterator it;
    757.     NDArray *freeArray;
    758.     fprintf(fp, "  freeList: (index, dataSize, pArray)\n");
    759.     epicsMutexLock(listLock_);
    760.     for (it=freeList_.begin(),i=0; it!=freeList_.end(); ++it,i++) {
    761.       fprintf(fp, "    %d %d %p\n", i, (int)it->dataSize_, it->pArray_);
    762.     }
    763.     // 每个NDArray的详细信息： NDArray对象的地址 DArray对象的维度数目  
    764.     // NDArray对象每个维度的元素数目  数据类型，数据尺寸，数据地址 唯一id，时间戳 引用计数 属性数目 每个属性信息
    765.     if (details > 10) {
    766.       for (it=freeList_.begin(); it!=freeList_.end(); ++it) {
    767.         freeArray = it->pArray_;
    768.         fprintf(fp, "    Array %d\n", i);
    769.         freeArray->report(fp, details);
    770.       }
    771.     }
    772.     epicsMutexUnlock(listLock_);
    773.   }
    774.   return ND_SUCCESS;
    775. }

    NDArrayPool类中方法的测试：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #include 
    13.  
    14. #include 
    15.  
    16. #include "asynNDArrayDriver.h"
    17. #include "NDArray.h"
    18.  
    19.  
    20. int main()
    21. {
    22.         // NDArrayPool::NDArrayPool(class asynNDArrayDriver *pDriver, size_t maxMemory)
    23.         printf("***********Test NDArrayPool construct:*********************\n");
    24.         NDArrayPool * pPool = new NDArrayPool(NULL, 10000);
    25.         printf("NDArrayPool information:\n");
    26.         pPool->report(stdout, 11);
    27.         printf("*************************************************************\n");
    28.  
    29.  
    30.         printf("**********************Test NDArrayPool::alloc:***************\n");
    31.         size_t dims[2] = {2,3};
    32.         int ndims = 2;
    33.         NDArray * pArray = pPool->alloc(ndims, dims, NDInt32, 0, NULL);
    34.         printf("NDArray Information:\n");
    35.         pArray->report(stdout, 11);
    36.         printf("NDArrayPool information:\n");
    37.         pPool->report(stdout , 11);
    38.         printf("*************************************************************\n");
    39.  
    40.         printf("********************Test NDArrayPool::copy:*****************\n");
    41.         NDArrayInfo_t info;
    42.         pArray->getInfo(&info);
    43.         size_t i;
    44.         size_t j;
    45.         printf("Set Value for pArray:\n");
    46.         epicsInt32* pArr = (epicsInt32 *)pArray->pData;
    47.         for (i = 0; i < info.nElements; i++){
    48.                 pArr[i] = i;
    49.         }
    50.         printf("copy a new NDArray from pArray:\n");
    51.         NDArray * pArrayout = pPool->copy(pArray, NULL, true, true, true);
    52.         pArrayout->getInfo(&info);
    53.         pArr = (epicsInt32 *)pArrayout->pData;
    54.         printf("xDim = %d, yDim = %d, xSize = %lu, ySize = %lu\n", info.xDim, info.yDim, info.xSize, info.ySize);
    55.         printf("output the values from the new NDArray:\n");
    56.         for (i = 0; i < info.ySize; i++){
    57.                 for (j = 0; j < info.xSize; j++){
    58.                         printf("%d\t", pArr[i * info.xSize + j]);
    59.                 }
    60.                 printf("\n");
    61.         }
    62.  
    63.         printf("\n");
    64.         printf("New created pArrayout information:\n");
    65.         pArrayout->report(stdout, 11);
    66.         printf("NDArrayPool information:\n");
    67.         pPool->report(stdout ,11);
    68.         printf("*************************************************************\n");
    69.  
    70.         printf("**********************Test NDArrayPool::reserve**************\n");
    71.         pPool->reserve(pArray);
    72.         printf("NDArray Information:\n");
    73.         pArray->report(stdout, 11);
    74.         printf("*************************************************************\n");
    75.  
    76.  
    77.         printf("**********************Test NDArrayPool:release**************\n");
    78.         printf("New created pArrayout information:\n");
    79.         pPool->release(pArrayout);
    80.         pPool->report(stdout ,11);
    81.         printf("*************************************************************\n");
    82.  
    83.         printf("Use NDArrayPool::alloc to allocate a new NDArray:*************\n");
    84.         dims[0] = 3;
    85.         dims[1] = 2;
    86.         printf("NDArrayPool Information:\n");
    87.         NDArray * pArrayOut = pPool->alloc(ndims, dims, NDFloat64, 0, NULL);
    88.         pArrayOut->report(stdout, 11);
    89.         printf("*************************************************************\n");
    90.         printf("**********************Use NArrayPool::convert***************\n");
    91.         NDArray * pnewNDArray = NULL;
    92.         //int NDArrayPool::convert(NDArray *pIn, NDArray **ppOut, NDDataType_t dataTypeOut, NDDimension_t *dimsOut)
    93.         pPool->convert(pArray, &pnewNDArray, NDFloat64, pArrayOut->dims);
    94.         pnewNDArray->report(stdout, 11);
    95.  
    96.         epicsFloat64 * pf64 = (epicsFloat64 *)pnewNDArray->pData;
    97.  
    98.         pnewNDArray->getInfo(&info);
    99.         printf("xDim = %d, yDim = %d, xSize = %lu, ySize = %lu\n", info.xDim, info.yDim, info.xSize, info.ySize);
    100.  
    101.         for (i = 0; i < info.ySize; i++){
    102.                 for (j = 0; j < info.xSize; j++){
    103.                         printf("%f\t", pf64[j + info.xSize * i]);
    104.                 }
    105.                 printf("\n");
    106.         }
    107.         printf("*************************************************************\n");
    108.  
    109.         pPool->report(stdout, 11);
    110.  
    111.         return 0;
    112. }

    测试结果如下：

    1. orangepi@orangepi5:~/C_program/host_program/hostApp$ O.linux-aarch64/testNDArrayPool
    2. ***********Test NDArrayPool construct:*********************
    3. NDArrayPool information:
    4.  
    5. NDArrayPool:
    6.   numBuffers=0, numFree=0
    7.   memorySize=0, maxMemory=10000
    8.   freeList: (index, dataSize, pArray)
    9. *************************************************************
    10. **********************Test NDArrayPool::alloc:***************
    11. NDArray Information:
    12.  
    13. NDArray  Array address=0x558d2d9090:
    14.   ndims=2 dims=[2 3 ]
    15.   dataType=4, dataSize=24, pData=0x558d2d92d0
    16.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    17.   referenceCount=1
    18.   number of attributes=0
    19.  
    20. NDAttributeList: address=0x558d2d9230:
    21.   number of attributes=0
    22. NDArrayPool information:
    23.  
    24. NDArrayPool:
    25.   numBuffers=1, numFree=0
    26.   memorySize=24, maxMemory=10000
    27.   freeList: (index, dataSize, pArray)
    28. *************************************************************
    29. ********************Test NDArrayPool::copy:*****************
    30. Set Value for pArray:
    31. copy a new NDArray from pArray:
    32. xDim = 0, yDim = 1, xSize = 2, ySize = 3
    33. output the values from the new NDArray:
    34. 0       1
    35. 2       3
    36. 4       5
    37.  
    38. New created pArrayout information:
    39.  
    40. NDArray  Array address=0x558d2d9310:
    41.   ndims=2 dims=[2 3 ]
    42.   dataType=4, dataSize=24, pData=0x558d2d92f0
    43.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    44.   referenceCount=1
    45.   number of attributes=0
    46.  
    47. NDAttributeList: address=0x558d2d94b0:
    48.   number of attributes=0
    49. NDArrayPool information:
    50.  
    51. NDArrayPool:
    52.   numBuffers=2, numFree=0
    53.   memorySize=48, maxMemory=10000
    54.   freeList: (index, dataSize, pArray)
    55. *************************************************************
    56. **********************Test NDArrayPool::reserve**************
    57. NDArray Information:
    58.  
    59. NDArray  Array address=0x558d2d9090:
    60.   ndims=2 dims=[2 3 ]
    61.   dataType=4, dataSize=24, pData=0x558d2d92d0
    62.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    63.   referenceCount=2
    64.   number of attributes=0
    65.  
    66. NDAttributeList: address=0x558d2d9230:
    67.   number of attributes=0
    68. *************************************************************
    69. **********************Test NDArrayPool:release**************
    70. New created pArrayout information:
    71.  
    72. NDArrayPool:
    73.   numBuffers=2, numFree=1
    74.   memorySize=48, maxMemory=10000
    75.   freeList: (index, dataSize, pArray)
    76.     0 24 0x558d2d9310
    77.     Array 1
    78.  
    79. NDArray  Array address=0x558d2d9310:
    80.   ndims=2 dims=[2 3 ]
    81.   dataType=4, dataSize=24, pData=0x558d2d92f0
    82.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    83.   referenceCount=0
    84.   number of attributes=0
    85.  
    86. NDAttributeList: address=0x558d2d94b0:
    87.   number of attributes=0
    88. *************************************************************
    89. Use NDArrayPool::alloc to allocate a new NDArray:*************
    90. NDArrayPool Information:
    91.  
    92. NDArray  Array address=0x558d2d95b0:
    93.   ndims=2 dims=[3 2 ]
    94.   dataType=9, dataSize=48, pData=0x558d2d97f0
    95.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    96.   referenceCount=1
    97.   number of attributes=0
    98.  
    99. NDAttributeList: address=0x558d2d9750:
    100.   number of attributes=0
    101. *************************************************************
    102. **********************Use NArrayPool::convert***************
    103.  
    104. NDArray  Array address=0x558d2d9830:
    105.   ndims=2 dims=[3 2 ]
    106.   dataType=9, dataSize=48, pData=0x558d2d9a70
    107.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    108.   referenceCount=1
    109.   number of attributes=0
    110.  
    111. NDAttributeList: address=0x558d2d99d0:
    112.   number of attributes=0
    113. xDim = 0, yDim = 1, xSize = 3, ySize = 2
    114. 0.000000        1.000000        2.000000
    115. 2.000000        3.000000        4.000000
    116. *************************************************************
    117.  
    118. NDArrayPool:
    119.   numBuffers=4, numFree=1
    120.   memorySize=144, maxMemory=10000
    121.   freeList: (index, dataSize, pArray)
    122.     0 24 0x558d2d9310
    123.     Array 1
    124.  
    125. NDArray  Array address=0x558d2d9310:
    126.   ndims=2 dims=[2 3 ]
    127.   dataType=4, dataSize=24, pData=0x558d2d92f0
    128.   uniqueId=0, timeStamp=0.000000, epicsTS.secPastEpoch=0, epicsTS.nsec=0
    129.   referenceCount=0
    130.   number of attributes=0
    131.  
    132. NDAttributeList: address=0x558d2d94b0:
    133.   number of attributes=0

  • 相关阅读:
    LabVIEW如何修复或重置NI MAX数据库文件
    Job 和 DaemonSet
    web安全渗透
    Facebook的创新实验室：人工智能与新技术探索
    热门项目！知识付费小程序源码系统 带完整的安装代码包以及安装部署教程
    Java架构师设计思想
    【Python】Python环境安装与简单代码运行
    在kubernetes中部署kubersphere
    【Unity3D】拖尾TrailRenderer
    高级Shopify主题开发教程
  • 原文地址：https://blog.csdn.net/yuyuyuliang00/article/details/133692126