473,836 Members | 1,590 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

Preventing memory fragmentation

Given the following information about memory management in C++:

-----
The c-runtime dynamic memory manager (and most other commercial memory
managers) has issues with fragmentation similar to a hard drive file
system.
Over time, the more often use call new/delete or alloc/free, there
will be
gaps and fragments in the heap. This can lead to inefficient use of
available memory, as well as cache-hit inefficiencies.

The goal of performance-critical applications is to minimize the
number of
calls to new/delete. Many use buffer managers that allocate blocks of
contiguous memory, and chain them together with list pointers when the
block
is consumed. Another approach is to use a Spare List, in which each
block of
memory is not actually freed but returned to a pool manager.
-----

I have implemented a memory pool that will coalesce blocks of memory
that are returned to the pool when they are freed up. I am interested
in the effectiveness of this implementation over the default memory
manager, and what I might want to change or consider when using the
pool in a specific application. I would appreciate any constructive
feedback this group has to offer.

The code to implement and test the pool is as follows:

#include <stdlib.h>
#include <time.h>
#include <string.h>

#include <new>
#include <list>

class MemoryPool
{
public:
explicit MemoryPool(size _t memorySize);
~MemoryPool();

void* Reserve(size_t size);
void Release(void* pMemory);

private:
typedef unsigned char Byte;
class Block
{
public:
static Block* FromMemory(void * pMemory);

explicit Block(size_t size, Block* pPrior = NULL, Block*
pNext = NULL);

size_t GetSize() const;
void* GetMemory();
Block* Prior();
Block* Next();

Block* SplitOff(size_t size);
Block* FuseWith( Block* pBlock);

private:
const Block* End() const;

size_t m_size;
Block* m_pPrior;
Block* m_pNext;
};

Block* m_pFirstBlock;
void* m_pMemoryPool;
};

MemoryPool::Mem oryPool
(
size_t memorySize
)
{
m_pMemoryPool = ::operator new(memorySize) ;
::memset(m_pMem oryPool, 0, memorySize);

size_t blockSize = memorySize - sizeof(Block);
m_pFirstBlock = new(m_pMemoryPo ol) Block(blockSize );
}

MemoryPool::~Me moryPool()
{
::operator delete(m_pMemor yPool);
}

void* MemoryPool::Res erve
(
size_t size
)
{
Block* pBlock = m_pFirstBlock;
while(pBlock->GetSize() < size){
pBlock = pBlock->Next();
if(NULL == pBlock){
throw std::bad_alloc( );
}
}

Block* pFreeBlock = pBlock->SplitOff(size) ;

if(NULL == pFreeBlock->Prior()){
m_pFirstBlock = pFreeBlock;
}

return pBlock->GetMemory();
}

void MemoryPool::Rel ease
(
void* pMemory
)
{
Block* pBlock = Block::FromMemo ry(pMemory);

Block* pNextBlock = m_pFirstBlock;
Block* pPriorBlock = NULL;

while(pBlock > pNextBlock){
pPriorBlock = pNextBlock;
pNextBlock = pNextBlock->Next();
if(NULL == pNextBlock){
break;
}
}

if(NULL != pNextBlock){
pBlock = pNextBlock->FuseWith(pBloc k);
}

if(NULL != pPriorBlock){
pPriorBlock->FuseWith(pBloc k);
}
else{
m_pFirstBlock = pBlock;
}
}

MemoryPool::Blo ck* MemoryPool::Blo ck::FromMemory
(
void* pMemory
)
{
Byte* pBytes = reinterpret_cas t<Byte*>(pMemor y);
return reinterpret_cas t<Block*>(pByte s - sizeof(Block));
}

MemoryPool::Blo ck::Block
(
size_t size,
Block* pPrior,
Block* pNext
) : m_size(size),
m_pPrior(pPrior ),
m_pNext(pNext)
{
}

size_t MemoryPool::Blo ck::GetSize() const
{
return m_size;
}

void* MemoryPool::Blo ck::GetMemory()
{
Byte* pMemory = reinterpret_cas t<Byte*>(this) ;
pMemory += sizeof(*this);
return pMemory;
}

MemoryPool::Blo ck* MemoryPool::Blo ck::Prior()
{
return m_pPrior;
}

MemoryPool::Blo ck* MemoryPool::Blo ck::Next()
{
return m_pNext;
}

MemoryPool::Blo ck* MemoryPool::Blo ck::SplitOff
(
size_t size
)
{
Block* pFreeBlock = NULL;
size_t totalSize = sizeof(*this) + size;
if((totalSize >= m_size)){
pFreeBlock = m_pNext;
pFreeBlock->m_pPrior = m_pPrior;
}
else{
Byte* pNextBlock = reinterpret_cas t<Byte*>(this) ;
pNextBlock += totalSize;

pFreeBlock = new(pNextBlock) Block(m_size - totalSize,
m_pPrior,
m_pNext);

if(NULL != m_pNext){
m_pNext->m_pPrior = pFreeBlock;
}
}

if(NULL != m_pPrior){
m_pPrior->m_pNext = pFreeBlock;
}

m_size = size;
m_pPrior = NULL;
m_pNext = NULL;

return pFreeBlock;
}

MemoryPool::Blo ck* MemoryPool::Blo ck::FuseWith
(
Block* pBlock
)
{
if(pBlock < this){
if(pBlock->End() == this){
pBlock->m_size += (sizeof(*this) + m_size);
pBlock->m_pNext = m_pNext;

if(NULL != m_pNext){
m_pNext->m_pPrior = pBlock;
}
}
else{
pBlock->m_pNext = this;
}
}

else{
if(this->End() == pBlock){
m_size += (sizeof(*this) + pBlock->GetSize());
m_pNext = pBlock->m_pNext;
return this;
}
else{
pBlock->m_pPrior = this;
m_pNext = pBlock;
}
}

return pBlock;
}

const MemoryPool::Blo ck* MemoryPool::Blo ck::End() const
{
const Byte* pEnd = reinterpret_cas t<const Byte*>(this);
pEnd += (sizeof(*this) + m_size);
return reinterpret_cas t<const Block*>(pEnd);
}

class Buffer
{
private:
typedef unsigned char Byte;

static const size_t POOL_SIZE = 4096;
static MemoryPool m_memoryPool;
Byte* m_pData;

public:
static void* operator new(size_t size);
static void operator delete(void* pMemory);

explicit Buffer(size_t size);
~Buffer();
};

MemoryPool Buffer::m_memor yPool(Buffer::P OOL_SIZE);

void* Buffer::operato r new
(
size_t size
)
{
return m_memoryPool.Re serve(size);
}

void Buffer::operato r delete
(
void* pMemory
)
{
m_memoryPool.Re lease(pMemory);
}

Buffer::Buffer
(
size_t size
)
{
m_pData = reinterpret_cas t<Byte*>(m_memo ryPool.Reserve( size));
::memset(m_pDat a, 0xFF, size);
}

Buffer::~Buffer ()
{
m_memoryPool.Re lease(m_pData);
}

typedef std::list<Buffe r*> BufferList;
typedef BufferList::ite rator BufferIterator;

void AddBuffer(Buffe rList* pList, size_t size = 0);
void RemoveBuffer(Bu fferList* pList, size_t buffer = 0);
void ClearBufferList (BufferList* pList);

void AddBuffer
(
BufferList* pList,
size_t size
)
{
const size_t MAX_BUFFER_SIZE = 128;
const size_t MIN_BUFFER_SIZE = 16;

if(0 == size){
size = ::rand() % MAX_BUFFER_SIZE + 1;
if(MIN_BUFFER_S IZE > size){
size = MIN_BUFFER_SIZE ;
}
}

pList->push_back(ne w Buffer(size));
}

void RemoveBuffer
(
BufferList* pList,
size_t buffer
)
{
size_t size = pList->size();

if(0 == buffer || (buffer >= size)){
buffer = ::rand() % size;
}

BufferIterator itBuffer = pList->begin();
std::advance(it Buffer, buffer);

Buffer* pBuffer = *itBuffer;
pList->erase(itBuffer );
delete pBuffer;
}

void ClearBufferList
(
BufferList* pList
)
{
BufferIterator itBuffer = pList->begin();
const BufferIterator itEND = pList->end();
while(itEND != itBuffer){
delete *itBuffer;
++itBuffer;
}
}

int main()
{
::srand(::time( NULL));
BufferList bufferList;

const int nBUFFER_COUNT = 20;
for(int nBuffer; nBUFFER_COUNT > nBuffer; ++nBuffer){
::AddBuffer(&bu fferList);
}

for(int nRemove = 0; 5 > nRemove; ++nRemove){
::RemoveBuffer( &bufferList) ;
}

for(int nTest = 0; 10 > nTest; ++nTest){
if(0 == ::rand() % 2){
::AddBuffer(&bu fferList);
}
else{
::RemoveBuffer( &bufferList) ;
}
}

::ClearBufferLi st(&bufferList) ;
}
Jul 22 '05 #1
18 6684

"Tron Thomas" <tr*********@ve rizon.net> wrote in message news:a4******** *************** ***@posting.goo gle.com...> > The c-> runtime
dynamic memory manager (and most other commercial memory
managers) has issues with framentaiton. This can lead to inefficient use of
available memory, as well as cache-hit inefficiencies.
True. Some allocators do better than others.
The goal of performance-critical applications is to minimize the
number of calls to new/delete.
The goal of performance-critical applications is to minimize EVERYTHING.
I aasume you mean to the global operator new/delete.
I have implemented a memory pool that will coalesce blocks of memory
that are returned to the pool when they are freed up.


So do almost every default allocator out there. Your code is also suboptimal
as it exhibits the well-known bad behavior of wandering all over memory touching
random pages when you are looking for a block. Further, I can't see anything
in your approach that does anything to diminish fragmentation,

You might want to google around for some of the prior art on this.

Jul 22 '05 #2
For my application I am only allocating a specific class of objects on
the heap, so I don't believe that I woud need to override the global
new and delete operators.

"Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* **************@ news.newshostin g.com>...
The goal of performance-critical applications is to minimize EVERYTHING.
I aasume you mean to the global operator new/delete.
I have implemented a memory pool that will coalesce blocks of memory
that are returned to the pool when they are freed up.
So do almost every default allocator out there. Your code is also suboptimal
as it exhibits the well-known bad behavior of wandering all over memory touching
random pages when you are looking for a block. Further, I can't see anything
in your approach that does anything to diminish fragmentation,


I expected that most allocator would already handle coalescing, so I
was really wondering what I was getting out of implementing it myself.
That's what motivated me to make this post

You might want to google around for some of the prior art on this.


I tried using Google to research before doing this implementation. I
did not find anything useful. What would you suggest I search under?
Jul 22 '05 #3

"Tron Thomas" <tr*********@ve rizon.net> wrote in message news:a4******** *************** **@posting.goog le.com...

I tried using Google to research before doing this implementation. I
did not find anything useful. What would you suggest I search under?


A ton of stuff shows up with
http://www.google.com/search?hl=en&i...ion+algorithms
Jul 22 '05 #4
On 23 Dec 2003 11:14:09 -0800, tr*********@ver izon.net (Tron Thomas)
wrote:
For my application I am only allocating a specific class of objects on
the heap, so I don't believe that I woud need to override the global
new and delete operators.


Just some thoughts:

(1) You can override new and delete in the class whose objects are to
be stored in a special way;

(2) You can use "placement new/delete" and allocate the raw memory
using something besides operator new.
--
Bob Hairgrove
No**********@Ho me.com
Jul 22 '05 #5
On 22 Dec 2003 09:44:42 -0800, tr*********@ver izon.net (Tron Thomas) wrote:
Given the following information about memory management in C++:

-----
The c-runtime dynamic memory manager (and most other commercial memory
managers) has issues with fragmentation similar to a hard drive file
system.
Over time, the more often use call new/delete or alloc/free, there
will be
gaps and fragments in the heap. This can lead to inefficient use of
available memory, as well as cache-hit inefficiencies.

The goal of performance-critical applications is to minimize the
number of
calls to new/delete. Many use buffer managers that allocate blocks of
contiguous memory, and chain them together with list pointers when the
block
is consumed. Another approach is to use a Spare List, in which each
block of
memory is not actually freed but returned to a pool manager.
-----

I have implemented a memory pool that will coalesce blocks of memory
that are returned to the pool when they are freed up. I am interested
in the effectiveness of this implementation over the default memory
manager, and what I might want to change or consider when using the
pool in a specific application. I would appreciate any constructive
feedback this group has to offer.

The code to implement and test the pool is as follows:

<snip>

Instead of asking for opinions, why not do some benchmarks? One
good benchmark trumps 1,000 opinions. Especially when the performance
of whole application is concerned.

See <http://www.microquill. com> for some tips on benchmarking
heap allocators. They also sell a very good heap allocator.

Are you really sure that heap fragmentation is a big issue? I'd be
interested in seeing some data, if you have it.

Don't forget that the reason for minimizing new/delete calls
is because they take time and they can cause a great deal of
contention in multi-threaded servers.

Slab allocators sound good, though I've never measured
one. See for example:
<http://srl.cs.jhu.edu/courses/600.418/SlabAllocator.p df>

A very quick once over (well it was more like a glance) of
the code gave me the impression that its a naive memory allocator;
though it's entirely possible that I missed something.

Walking a linked list of blocks is likely to cache unfriendly.
I didn't even see the simple stuff like multiple pools for different
sizes of block, let alone, processor or thread specific pools.

And where do you deal with the minimum alignment?

You might also want to check out the Hoard allocator
at <www.hoard.org> . I tested it against the Microquil
allocator a few years ago and the Microquill allocator,
SmartHeap, was much faster in my application.

Bob S

Jul 22 '05 #6
I thought I was doing this in the implementation code I posted.

wouldnt_you_lik e@to_know.com (Bob Hairgrove) wrote in message news:<3f******* *******@news.we bshuttle.ch>...
On 23 Dec 2003 11:14:09 -0800, tr*********@ver izon.net (Tron Thomas)
wrote:
For my application I am only allocating a specific class of objects on
the heap, so I don't believe that I woud need to override the global
new and delete operators.


Just some thoughts:

(1) You can override new and delete in the class whose objects are to
be stored in a special way;

(2) You can use "placement new/delete" and allocate the raw memory
using something besides operator new.

Jul 22 '05 #7
"Ron Natalie" <ro*@sensor.com > wrote in message news:<3f******* *************** *@news.newshost ing.com>...
"Tron Thomas" <tr*********@ve rizon.net> wrote in message news:a4******** *************** **@posting.goog le.com...

I tried using Google to research before doing this implementation. I
did not find anything useful. What would you suggest I search under?


A ton of stuff shows up with
http://www.google.com/search?hl=en&i...ion+algorithms


Yes, I have conducted simular searches that returned many results as
well. However, I have never found any site that really discuss how to
deal with memory fragmentation.

One suggested technique is free space compaction. This would imply
using handles as you have to shift memory around to compact memory,
and I believe that handles might be difficult to incoporate into what
is already implemented.

Most site discuss method of finding a free block, such as first fit
which means to find the first free block that will satisfy the
request. This is what I implemented for my memory pool. One web site
suggested that first fit is one of the methods that leads to less
memory fragmentation than others. So that might be a plus for what
I've done so far.

I have reviewed the code for the project where I want to handle memory
differently. It turns out there are only 3 classes that allocate
objects on the heap frequenty. Other classes only instantiate one
object during the lifetime of the program and wouldn't contribute much
to fragmentation.

Objects created from these three classes are all of fixed sizes. I'm
thinking I could override operator new for each of these classes where
I reserve a pool that would contain a certain number of blocks, each
of which can hold one object.

Since all objects are the same size, one block is as good as another
and the fact that the pool might become fragmented wouldn't matter too
much. Memory wouldn't be wasted as all blocks in the free list would
be able to hold a desired object regardless of its location it the
list.
Jul 22 '05 #8
po************* ********@yahoo. com (Bob Summers) wrote in message news:<3f******* ********@news.c oncentric.net>. ..
Instead of asking for opinions, why not do some benchmarks? One
good benchmark trumps 1,000 opinions. Especially when the performance
of whole application is concerned.

See <http://www.microquill. com> for some tips on benchmarking
heap allocators. They also sell a very good heap allocator.

Are you really sure that heap fragmentation is a big issue? I'd be
interested in seeing some data, if you have it.

Don't forget that the reason for minimizing new/delete calls
is because they take time and they can cause a great deal of
contention in multi-threaded servers.

Slab allocators sound good, though I've never measured
one. See for example:
<http://srl.cs.jhu.edu/courses/600.418/SlabAllocator.p df>

A very quick once over (well it was more like a glance) of
the code gave me the impression that its a naive memory allocator;
though it's entirely possible that I missed something.

Walking a linked list of blocks is likely to cache unfriendly.
I didn't even see the simple stuff like multiple pools for different
sizes of block, let alone, processor or thread specific pools.

And where do you deal with the minimum alignment?

You might also want to check out the Hoard allocator
at <www.hoard.org> . I tested it against the Microquil
allocator a few years ago and the Microquill allocator,
SmartHeap, was much faster in my application.

Bob S


The comments I listed in my post concerning fragmentation were based
on criticism given by a company where I applied for a programming
position. I sent them the code from some projects I had done and they
were concerned about the way I handled memory in one of my programs,
even though they had never run the program and done any benchmarks
against it.

The program is not that complicated and seems to run fine as it is. I
thought there would be value in dealing with the criticism they
offered in case someone else should review the code and come to a
similar conclusion. Plus, it would be a good learning experience.

I believe I have a strategy that will improve things. I will also
look at the links you suggested.

What exactly is minium alignment and how is it usually dealt with?
Jul 22 '05 #9
Tron Thomas wrote:
The comments I listed in my post concerning fragmentation were
based on criticism given by a company where I applied for a
programming position. I sent them the code from some projects I
had done and they were concerned about the way I handled memory
in one of my programs, even though they had never run the program
and done any benchmarks against it.
Did you try asking them for (or simply did you get) specifics
beyond, "it'll fragment memory"?
The program is not that complicated and seems to run fine as it
is. I thought there would be value in dealing with the criticism
they offered in case someone else should review the code and come
to a similar conclusion. Plus, it would be a good learning
experience.
Is it this memory pool class you wrote that does your allocation?
I.e. is this the memory manager that they called into question?
I believe I have a strategy that will improve things. I will
also look at the links you suggested.
While looking at other memory managers is always a good idea,
generally the most bang for your buck comes from minimizing the
need for one in the first place.

Your memory manager is THE naive memory manager. No offense
intended, it's just pretty much the most basic memory manager
that there could be.

When I say, "minimize the need for [a memory manager]," I mean,
do all that you can to strip calls to new and delete out of your
codebase. Or, push all of those calls to program initialization
or something.

I write video games for a living. We target small-memory
machines, so in addition to the performance ramifications of
general purpose memory management, fragmentation is a terrible
problem. Fragmentation hits us hard (or could, anyway, if we
used memory allocation naively) because there are a lot of small
allocations that are relatively temporary and a lot of large
allocations that stick around. So, you might allocate a few
small things, allocate a big thing, toss the small things, then
the next big thing can't fit into the small things space that's
now free.

The "solution" for us has always been to limit memory allocation
to being at startup, and to not ever call delete. So, you
allocate a bunch of stuff that you actually need, and you keep
that stuff around forever. This meant that stuff like the amount
of text on screen had a maximum (the text system allocated
buffers big enough for TEXT_NUM_CHARS or some such), there could
be a fixed maximum number of bullet holes strewn about the world,
and there was a fixed number of enemy characters that could be
visible on-screen at any given time. This pushed "dynamic"
memory management off to the different object types that managed
their own types of pools, but this actually ended up being
factored out into "base functionality" for most cases that needed
this sort of thing.
What exactly is minium alignment and how is it usually dealt
with?


The PlayStation2 RAM, for example, is set up so that it's really
easy to read things on 64k boundaries, slightly less easy to read
on any arbitrary 16-byte boundary, and only possible to read on
32-bit boundaries into the main CPU. In other words, "minimum
alignment" changes depending on what you're trying to do.
Arguably the memory allocator should be aware of these issues.
Anything that we wanted to DMA anywhere needed to live on these
16-byte boundaries, but if we had any blocks of anything that we
ever wanted to send anywhere, we actually wanted to do our best
to stick them on 64k boundaries, or far enough away from those
boundaries such that the data that the DMA hardware needed could
fit right at the boundary...

-tom!
Jul 22 '05 #10

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

8
2031
by: cody | last post by:
i basically want to create an object which contains an array (the last element of the class). the size of the array is determined when the object is created. for performance reasons (avoiding cache misses) the whole objekt should be in one linear chunk of memory, that is the array starts where the objekt ends in memory. class Cool { Cool (int arraysize) { .. }
8
6865
by: Tron Thomas | last post by:
As part of applying for a programming position at a company, I recently I had submitted some code samples to one of the developers for review. This is the feedback I received: One of his concerns was frequent calls to new and delete, which can cause memory fragmentation over time. An example is the allocation and destruction
5
2008
by: DLPnet | last post by:
Hello, I m working on Windows and Mac in C++. My application uses a lot of memory since it s dealing with a lot of images. So I load images in a cache when needed and if I haven t enough memory to load next image I remove first ones from the cache. But I have a lot of problems with memory. A lot of time when I just ask for memory, a big chunk of memory though, like for example 200 Mo the
13
5719
by: Rob Corwin | last post by:
Hi, a c# app of mine that parses 30,000 xml files writes large amounts of data to file (> 2GB) using a streamwriter object (sw). everything works fine except that the memory used by the app grows linearly during execution and eventually crashes the computer. without going into too much detail of my code, i made the following observations: - if you comment out the sw.Write(x) statement (which is inside the loop that parses the xml...
3
3764
by: Florin | last post by:
Hi all, I have a problem related to memory grow on a server application which is basically stateless (I have some static info loaded). The client accesses this server using remoting and it has worked for about 2 years without problems. The problem I have encountered lately is that the memory on server side started to grow and not to be released. I have checked first new functionalities but after isolating these on separate server, the...
9
4221
by: jeungster | last post by:
Hello, I'm trying to track down a memory issue with a C++ application that I'm working on: In a nutshell, the resident memory usage of my program continues to grow as the program runs. It starts off at a nice 4% of memory, then slowly grows up to 50% and beyond. This translates to around 2 gigs of physical memory, and that's really way more memory than this program should be taking up.
5
3350
by: vishnu | last post by:
Hi there, I am embedding python 2.5 on embedded system running on RTOS where I had strict memory constraints. As python is a huge malloc intensive application, I observed huge memory fragmentation in my system which is leading to out of memory after running few scripts. So I decided to re-initialise the python with out restarting the whole python. I tried to use Py_Finalise() after completion of each script , then call Py_Initialise as...
5
6219
by: Andreas Schmitt | last post by:
Hi, I recently worked on an open source project and tried to make on of the arrays they are using dynamically allocated to get rid of the max size. I used the realloc instead of the usual C++ new and delete because they asked me to stick to their "coding style" Well whatever..
8
3626
by: jacek.dziedzic | last post by:
Hi! I need to be able to track memory usage in a medium-sized application I'm developing. The only significant (memory-wise) non- local objects are of two types -- std::vector<and of a custom class simple_vector<that is a hand-rolled substitute for array<>. With the latter I have code that tracks all allocations and destructions, so I can account for all the memory. The question is about std::vector<-- how can I track memory usage
0
9825
marktang
by: marktang | last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look ! Part I. Meaning of...
0
9671
by: Hystou | last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can effortlessly switch the default language on Windows 10 without reinstalling. I'll walk you through it. First, let's disable language synchronization. With a Microsoft account, language settings sync across devices. To prevent any complications,...
0
10852
Oralloy
by: Oralloy | last post by:
Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed. This is as boiled down as I can make it. Here is my compilation command: g++-12 -std=c++20 -Wnarrowing bit_field.cpp Here is the code in...
0
9382
agi2029
by: agi2029 | last post by:
Let's talk about the concept of autonomous AI software engineers and no-code agents. These AIs are designed to manage the entire lifecycle of a software development project—planning, coding, testing, and deployment—without human intervention. Imagine an AI that can take a project description, break it down, write the code, debug it, and then launch it, all on its own.... Now, this would greatly impact the work of software developers. The idea...
1
7793
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms. Adolph will...
0
6980
by: conductexam | last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one. At the time of converting from word file to html my equations which are in the word document file was convert into image. Globals.ThisAddIn.Application.ActiveDocument.Select();...
0
5651
by: TSSRALBI | last post by:
Hello I'm a network technician in training and I need your help. I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs. The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols. I succeeded, with both firewalls in the same network. But I'm wondering if it's possible to do the same thing, with 2 Pfsense firewalls...
1
4459
by: 6302768590 | last post by:
Hai team i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
2
4021
muto222
by: muto222 | last post by:
How can i add a mobile payment intergratation into php mysql website.

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.