开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
AtmiBrokerMem.cxx
资源名称：blacktie-2.0.0.M3-src.zip　[点击查看]
上传用户：xfwatch
上传日期：2020-12-14
资源大小：872k
文件大小：12k
源码类别：

中间件编程

开发平台：

Java

AtmiBrokerMem.cxx：源码内容
  1. /*
  2.  * JBoss, Home of Professional Open Source
  3.  * Copyright 2008, Red Hat, Inc., and others contributors as indicated
  4.  * by the @authors tag. All rights reserved.
  5.  * See the copyright.txt in the distribution for a
  6.  * full listing of individual contributors.
  7.  * This copyrighted material is made available to anyone wishing to use,
  8.  * modify, copy, or redistribute it subject to the terms and conditions
  9.  * of the GNU Lesser General Public License, v. 2.1.
  10.  * This program is distributed in the hope that it will be useful, but WITHOUT A
  11.  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  13.  * You should have received a copy of the GNU Lesser General Public License,
  14.  * v.2.1 along with this distribution; if not, write to the Free Software
  15.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16.  * MA  02110-1301, USA.
  17.  */
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <string.h>
  22. #include <stdarg.h>
  23. #include <iostream>
  25. #include "xatmi.h"
  26. #include "AtmiBrokerMem.h"
  27. #include "AtmiBrokerClient.h"
  28. #include "log4cxx/logger.h"
  29. #include "ThreadLocalStorage.h"
  30. #include "AtmiBrokerEnvXml.h"
  32. log4cxx::LoggerPtr AtmiBrokerMem::logger(log4cxx::Logger::getLogger(
  33. "AtmiBrokerMem"));
  34. SynchronizableObject* AtmiBrokerMem::lock = new SynchronizableObject();
  36. AtmiBrokerMem * AtmiBrokerMem::ptrAtmiBrokerMem = NULL;
  38. AtmiBrokerMem *
  39. AtmiBrokerMem::get_instance() {
  40. LOG4CXX_TRACE(logger, (char*) "get_instance locking");
  41. lock->lock();
  42. LOG4CXX_TRACE(logger, (char*) "get_instance locked");
  43. if (ptrAtmiBrokerMem == NULL)
  44. ptrAtmiBrokerMem = new AtmiBrokerMem();
  45. lock->unlock();
  46. LOG4CXX_TRACE(logger, (char*) "get_instance unlocked");
  47. return ptrAtmiBrokerMem;
  48. }
  50. void AtmiBrokerMem::discard_instance() {
  51. LOG4CXX_TRACE(logger, (char*) "discard_instance locking");
  52. lock->lock();
  53. LOG4CXX_TRACE(logger, (char*) "discard_instance locked");
  54. if (ptrAtmiBrokerMem != NULL) {
  55. delete ptrAtmiBrokerMem;
  56. ptrAtmiBrokerMem = NULL;
  57. }
  58. lock->unlock();
  59. LOG4CXX_TRACE(logger, (char*) "discard_instance unlocked");
  60. }
  62. AtmiBrokerMem::AtmiBrokerMem() {
  63. LOG4CXX_DEBUG(logger, (char*) "constructor");
  64. }
  66. AtmiBrokerMem::~AtmiBrokerMem() {
  67. LOG4CXX_DEBUG(logger, (char*) "destructor assumes you have the lock....");
  68. LOG4CXX_DEBUG(logger, (char*) "memoryInfoVector.size "
  69. << memoryInfoVector.size());
  70. std::vector<MemoryInfo>::iterator it = memoryInfoVector.begin();
  71. while (it != memoryInfoVector.end()) {
  72. MemoryInfo memoryInfo = (*it);
  73. LOG4CXX_DEBUG(logger, (char*) "freeing memoryPtr");
  74. if (memoryInfo.memoryPtr != NULL) {
  75. LOG4CXX_DEBUG(logger, (char*) "freeing memoryPtr");
  76. free(memoryInfo.memoryPtr);
  77. }
  78. if (memoryInfo.type != NULL) {
  79. LOG4CXX_DEBUG(logger, (char*) "freeing type");
  80. free(memoryInfo.type);
  81. }
  82. if (memoryInfo.subtype != NULL) {
  83. LOG4CXX_DEBUG(logger, (char*) "freeing subtype");
  84. free(memoryInfo.subtype);
  85. }
  86. LOG4CXX_DEBUG(logger, (char*) "freed memory");
  88. LOG4CXX_DEBUG(logger, (char*) "removing  from vector");
  89. it = memoryInfoVector.erase(it);
  90. LOG4CXX_DEBUG(logger, (char*) "removed from vector ");
  91. }
  92. memoryInfoVector.clear();
  93. LOG4CXX_TRACE(logger, (char*) "freeAllMemory unlocked");
  94. }
  96. char*
  97. AtmiBrokerMem::tpalloc(char* type, char* subtype, long size,
  98. bool serviceAllocated) {
  99. char* toReturn = NULL;
  100. LOG4CXX_TRACE(logger, (char*) "tpalloc locking");
  101. lock->lock();
  102. LOG4CXX_TRACE(logger, (char*) "tpalloc locked");
  103. if (!type) {
  104. LOG4CXX_ERROR(logger, (char*) "tpalloc - no type");
  105. setSpecific(TPE_KEY, TSS_TPEINVAL);
  106. } else if ((strncmp(type, "X_COMMON", MAX_TYPE_SIZE) == 0 || strncmp(type,
  107. "X_C_TYPE", MAX_TYPE_SIZE) == 0) && !subtype) {
  108. LOG4CXX_ERROR(logger, (char*) "tpalloc - no subtype");
  109. setSpecific(TPE_KEY, TSS_TPEINVAL);
  110. } else if ((strncmp(type, "X_COMMON", MAX_TYPE_SIZE) == 0 || strncmp(type,
  111. "X_C_TYPE", MAX_TYPE_SIZE) == 0) && buffers[subtype] == NULL) {
  112. LOG4CXX_ERROR(logger, (char*) "tpalloc - unknown buffer type: "
  113. << subtype);
  114. setSpecific(TPE_KEY, TSS_TPEINVAL);
  115. } else if (size < 0) {
  116. LOG4CXX_ERROR(logger, (char*) "tpalloc - negative size");
  117. setSpecific(TPE_KEY, TSS_TPEINVAL);
  118. } else if (strncmp(type, "X_OCTET", 8) == 0 && size == 0) {
  119. LOG4CXX_ERROR(logger, (char*) "tpalloc - buffer type requires size");
  120. setSpecific(TPE_KEY, TSS_TPEINVAL);
  121. } else if (strncmp(type, "X_OCTET", MAX_TYPE_SIZE) != 0 && strncmp(type,
  122. "X_COMMON", MAX_TYPE_SIZE) != 0 && strncmp(type, "X_C_TYPE",
  123. MAX_TYPE_SIZE) != 0) {
  124. LOG4CXX_ERROR(logger, (char*) "tpalloc DONT YET know type: " << type);
  125. setSpecific(TPE_KEY, TSS_TPENOENT);
  126. } else {
  127. if (strcmp(type, "X_OCTET") == 0) {
  128. LOG4CXX_DEBUG(logger, (char*) "tpalloc character array ");
  129. subtype = (char*) "";
  130. } else if (strcmp(type, "X_COMMON") == 0 || strcmp(type, "X_C_TYPE")
  131. == 0) {
  132. if (!serviceAllocated && size != 0) {
  133. LOG4CXX_WARN(logger,
  134. (char*) "tpalloc - X_C_TYPE/X_COMMON size should be 0");
  135. }
  136. LOG4CXX_DEBUG(logger, (char*) "tpalloc X_C_TYPE/X_COMMON");
  137. size = buffers[subtype]->memSize;
  138. }
  139. LOG4CXX_DEBUG(logger, (char*) "tpalloc - type: subtype: size:" << type
  140. << ":" << subtype << ":" << size);
  141. MemoryInfo memoryInfo;
  142. LOG4CXX_TRACE(logger, (char*) "tpalloc - created memoryInfo");
  143. memoryInfo.memoryPtr = (char*) malloc(size);
  144. memoryInfo.size = size;
  145. memset(memoryInfo.memoryPtr, '', memoryInfo.size);
  146. LOG4CXX_TRACE(logger, (char*) "tpalloc - sized: " << size);
  148. memoryInfo.type = (char*) malloc(MAX_TYPE_SIZE + 1);
  149. memset(memoryInfo.type, '', MAX_TYPE_SIZE + 1);
  150. LOG4CXX_TRACE(logger, (char*) "type prep");
  151. strncpy(memoryInfo.type, type, MAX_TYPE_SIZE);
  152. LOG4CXX_TRACE(logger, (char*) "tpalloc - copied type/"
  153. << memoryInfo.type << "/");
  155. memoryInfo.subtype = (char*) malloc(MAX_SUBTYPE_SIZE + 1);
  156. memset(memoryInfo.subtype, '', MAX_SUBTYPE_SIZE + 1);
  157. strncpy(memoryInfo.subtype, subtype, MAX_SUBTYPE_SIZE);
  158. LOG4CXX_TRACE(logger, (char*) "tpalloc - copied subtype/"
  159. << memoryInfo.subtype << "/");
  161. memoryInfo.forcedDelete = serviceAllocated;
  163. LOG4CXX_DEBUG(
  164. logger,
  165. (char*) "adding MemoryInfo: with type: with subtype: with size: to vector"
  166. << memoryInfo.type << ":" << memoryInfo.subtype << ":"
  167. << memoryInfo.size);
  168. memoryInfoVector.push_back(memoryInfo);
  169. LOG4CXX_DEBUG(logger, (char*) "added MemoryInfo to vector: "
  170. << memoryInfoVector.size());
  171. toReturn = (char*) memoryInfo.memoryPtr;
  172. }
  173. lock->unlock();
  174. LOG4CXX_TRACE(logger, (char*) "tpalloc unlocked");
  175. return toReturn;
  176. }
  178. char* AtmiBrokerMem::tprealloc(char * addr, long size, char* type,
  179. char* subtype, bool force) {
  180. char* toReturn = NULL;
  181. LOG4CXX_TRACE(logger, (char*) "tprealloc locking");
  182. lock->lock();
  183. LOG4CXX_TRACE(logger, (char*) "tprealloc locked");
  184. if (!addr) {
  185. LOG4CXX_ERROR(logger, (char*) "tprealloc - no buffer");
  186. setSpecific(TPE_KEY, TSS_TPEINVAL);
  187. } else if (size < 0) {
  188. LOG4CXX_ERROR(logger, (char*) "tprealloc - negative size");
  189. setSpecific(TPE_KEY, TSS_TPEINVAL);
  190. } else if (size == 0) {
  191. LOG4CXX_ERROR(logger, (char*) "tprealloc - requires positive size");
  192. setSpecific(TPE_KEY, TSS_TPEINVAL);
  193. } else {
  194. LOG4CXX_DEBUG(logger, (char*) "tprealloc hunting " << size);
  195. for (std::vector<MemoryInfo>::iterator it = memoryInfoVector.begin(); it
  196. != memoryInfoVector.end(); it++) {
  197. LOG4CXX_TRACE(logger, (char*) "next memoryInfo id is with size: "
  198. << (*it).size);
  199. if ((force == false) && (strncmp((*it).type, "X_COMMON",
  200. MAX_TYPE_SIZE) == 0 || strncmp((*it).type, "X_C_TYPE",
  201. MAX_TYPE_SIZE) == 0)) {
  202. LOG4CXX_WARN(
  203. logger,
  204. (char*) "tprealloc - cannot resize a X_C_TYPE/X_COMMON buffer");
  205. break;
  206. } else if ((*it).memoryPtr == addr) {
  207. LOG4CXX_DEBUG(logger, (char*) "found matching memory with size"
  208. << (*it).size);
  209. char* memPtr = (char*) realloc((void*) addr, size);
  210. (*it).memoryPtr = memPtr;
  211. (*it).size = size;
  212. memset((*it).memoryPtr, '', (*it).size);
  213. toReturn = memPtr;
  215. if (type != NULL) {
  216. free((*it).type);
  217. (*it).type = (char*) malloc(MAX_TYPE_SIZE + 1);
  218. memset((*it).type, '', MAX_TYPE_SIZE + 1);
  219. LOG4CXX_TRACE(logger, (char*) "type prep");
  220. strncpy((*it).type, type, MAX_TYPE_SIZE);
  221. LOG4CXX_TRACE(logger, (char*) "tpalloc - copied type/"
  222. << (*it).type << "/");
  223. }
  225. if (subtype != NULL) {
  226. free((*it).subtype);
  227. (*it).subtype = (char*) malloc(MAX_SUBTYPE_SIZE + 1);
  228. memset((*it).subtype, '', MAX_SUBTYPE_SIZE + 1);
  229. strncpy((*it).subtype, subtype, MAX_SUBTYPE_SIZE);
  230. LOG4CXX_TRACE(logger, (char*) "tpalloc - copied subtype/"
  231. << (*it).subtype << "/");
  232. }
  234. LOG4CXX_DEBUG(logger, (char*) "updated - size: " << size);
  235. break;
  236. }
  237. }
  239. if (toReturn == NULL) {
  240. LOG4CXX_TRACE(logger, (char*) "tprealloc - not found addr");
  241. setSpecific(TPE_KEY, TSS_TPEINVAL);
  242. LOG4CXX_TRACE(logger, (char*) "tprealloc - failure advised");
  243. }
  244. }
  245. lock->unlock();
  246. LOG4CXX_TRACE(logger, (char*) "tprealloc unlocked");
  247. return toReturn;
  248. }
  250. void AtmiBrokerMem::tpfree(char* ptr, bool force) {
  251. bool found = false;
  252. LOG4CXX_TRACE(logger, (char*) "tpfree locking");
  253. lock->lock();
  254. LOG4CXX_TRACE(logger, (char*) "tpfree locked");
  255. if (ptr && ptr != NULL) {
  256. LOG4CXX_DEBUG(logger, (char*) "tpfree: " << memoryInfoVector.size());
  257. for (std::vector<MemoryInfo>::iterator it = memoryInfoVector.begin(); it
  258. != memoryInfoVector.end(); it++) {
  259. // LOG4CXX_TRACE(logger, (char*) "next memoryInfo id is: "
  260. // << (char*) (*it).memoryPtr);
  261. if ((*it).memoryPtr == NULL) {
  262. LOG4CXX_ERROR(logger, (char*) "found a null in the vector");
  263. break;
  264. }
  265. MemoryInfo memoryInfo = (*it);
  266. if (memoryInfo.memoryPtr == ptr) {
  267. if (!memoryInfo.forcedDelete || (memoryInfo.forcedDelete
  268. && force)) {
  269. LOG4CXX_DEBUG(logger,
  270. (char*) "freeing memoryPtr to reclaim: "
  271. << memoryInfo.size);
  272. free(memoryInfo.memoryPtr);
  273. if (memoryInfo.type != NULL) {
  274. LOG4CXX_DEBUG(logger, (char*) "freeing type");
  275. free(memoryInfo.type);
  276. }
  277. if (memoryInfo.subtype != NULL) {
  278. LOG4CXX_DEBUG(logger, (char*) "freeing subtype");
  279. free(memoryInfo.subtype);
  280. }
  281. LOG4CXX_DEBUG(logger, (char*) "freed memory");
  283. LOG4CXX_DEBUG(logger, (char*) "removing  from vector");
  284. memoryInfoVector.erase(it);
  285. LOG4CXX_DEBUG(logger, (char*) "removed from vector ");
  287. found = true;
  288. break;
  289. } else {
  290. LOG4CXX_DEBUG(logger,
  291. (char*) "tpfree without force ignored");
  292. }
  293. }
  294. }
  295. LOG4CXX_DEBUG(logger, (char*) "tpfreed: " << memoryInfoVector.size());
  296. }
  297. LOG4CXX_TRACE(logger, (char*) "tpfree unlocking");
  298. lock->unlock();
  299. LOG4CXX_TRACE(logger, (char*) "tpfree unlocked");
  300. return;
  301. }
  303. long AtmiBrokerMem::tptypes(char* ptr, char* type, char* subtype) {
  304. LOG4CXX_TRACE(logger, (char*) "tptypes locking");
  305. lock->lock();
  306. LOG4CXX_TRACE(logger, (char*) "tptypes locked");
  307. long toReturn = -1;
  308. if (ptr && ptr != NULL) {
  309. LOG4CXX_DEBUG(logger, (char*) "ptr appeared valid");
  310. for (std::vector<MemoryInfo>::iterator it = memoryInfoVector.begin(); it
  311. != memoryInfoVector.end(); it++) {
  312. LOG4CXX_TRACE(logger, (char*) "next memoryInfo is with size: "
  313. << (*it).size);
  314. if ((*it).memoryPtr == ptr) {
  315. MemoryInfo memoryInfo = (*it);
  316. LOG4CXX_DEBUG(logger, (char*) "found matching memory");
  318. if (type && type != NULL) {
  319. strncpy(type, memoryInfo.type, MAX_TYPE_SIZE);
  320. }
  321. if (subtype && subtype != NULL) {
  322. strncpy(subtype, memoryInfo.subtype, MAX_SUBTYPE_SIZE);
  323. }
  324. toReturn = memoryInfo.size;
  325. break;
  326. }
  327. }
  328. }
  329. if (toReturn == -1) {
  330. // WAS NOT FOUND
  331. LOG4CXX_TRACE(logger, (char*) "notifying could not found");
  332. setSpecific(TPE_KEY, TSS_TPEINVAL);
  333. }
  334. LOG4CXX_TRACE(logger, (char*) "tptypes unlocking");
  335. lock->unlock();
  336. LOG4CXX_TRACE(logger, (char*) "tptypes unlocked");
  337. return toReturn;
  338. }