Tuesday, March 14, 2017

Digest for comp.lang.c++@googlegroups.com - 25 updates in 12 topics

"Christopher J. Pisz" <cpisz@austin.rr.com>: Mar 13 11:00PM -0500

If I understand emplace correctly, rather than make an object and pass
it to emplace, I pass the arguments to the object's constructor and it
is "created in place", saving a copy construction.
 
This works handy for vector<T> myVector; by calling
myVector.emplace_back with T's constructor arguments.
 
However, when I use unordered_map<int, T> and call emplace, it seems I
need to pass the arguments to the pair, one of which is going to be T(),
so I am still making an extra copy of T...
 
Is there some way around that?
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 14 03:46PM +0100

On 14-Mar-17 5:00 AM, Christopher J. Pisz wrote:
> need to pass the arguments to the pair, one of which is going to be T(),
> so I am still making an extra copy of T...
 
> Is there some way around that?
 
When you control the wrapper's code (here that would be the pair class'
code) then you can use Boost in-place factories.
 
See <url:
http://www.boost.org/doc/libs/1_61_0/libs/optional/doc/html/boost_optional/tutorial/in_place_factories.html>.
 
I don't like that solution: it feels unclean, what with a `void*`
involved, and just in general. But it's a solution for a general class
of cases. Which does not include your case; just worth being aware of.
 
• • •
 
Otherwise you can use indirection.
 
David Wheeler: "All problems in computer science can be solved by
another level of indirection".
 
Essentially that means using pointers as your value type, and dynamic
allocation.
 
Uh oh… "Dynamic allocation"?!? That's going to take one heck of a
performance hit, won't it?
 
Well no, not if it's done right for this particular case. Because your
container is clearly the /owner/ of those value objects. And that means
that ordinary slow-as-molasses inefficient raw C++ dynamic allocation
can be replaced with super-fast dedicated dynamic allocation.
 
It can be done in many different ways.
 
The idea that popped up from my association circuits as "the" way to do
that is to use a sequence `std::vector`s as storage, and a free-list to
manage individual items. When all allocated storage has been used,
create a new vector of double size as the last one. The doubling
strategy (which is similar to a vector's internal buffer management)
means that the number of raw dynamic allocations will only be O(log n)
in the number of items managed by the allocator.
 
Example, showing only the allocation idea, with debugging / clarifying
clog statements:
 
 
#include <utility> // std::move
#include <vector> // std::vector
#include <stack> // std::stack
#include <stddef.h> // ptrdiff_t
#include <type_traits> // std::(aligned_storage)
 
#include <iostream>
using std::clog;
 
namespace my {
using std::aligned_union_t;
using std::move;
using std::stack;
using std::vector;
 
using Size = ptrdiff_t;
 
struct Node
{
Node* next;
};
 
auto unlinked( Node*& p )
-> Node*
{
Node* result = p;
p = p->next;
return result;
}
 
// This class is just to be sure that no vector is ever /copied/,
because that
// could invalidate pointers and references to items in its buffer.
template< class Item >
struct Non_copyable_vector
{
vector<Item> v;
 
Non_copyable_vector() {}
 
Non_copyable_vector( Non_copyable_vector const& ) = delete;
 
Non_copyable_vector( Non_copyable_vector&& other )
: v( move( other.v ) ) // vector guarantees ptr validity
after move.
{} // (which is why it can't use fast
`realloc`)
};
 
namespace tag {
template< class Item >
struct Storage_ptr_ { Item* value; };
 
struct Do_nothing {};
};
 
template< class Item >
class Fixed_size_allocator
{
private:
using Item_storage_bytes = aligned_union_t< 0, Item, Node >;
static_assert( alignof( Item_storage_bytes ) >= alignof( Item
), "!" );
static_assert( alignof( Item_storage_bytes ) >= alignof( Node
), "!" );
 
struct Item_storage
{
Item_storage_bytes bytes;
Item_storage( tag::Do_nothing ) {} // Fast do-nothing
construction.
};
static_assert( alignof( Item_storage ) >= alignof(
Item_storage_bytes ), "!" );
 
using Storage = stack< Non_copyable_vector< Item_storage > >;
 
Storage storage_;
Node* first_free_ = nullptr;
 
public:
auto allocate()
-> tag::Storage_ptr_<Item> // Points to uninitialized
storage.
{
if( first_free_ )
{
clog << "| using first free\n";
return { reinterpret_cast<Item*>( unlinked( first_free_
) ) };
}
 
if( storage_.top().v.size() == storage_.top().v.capacity() )
{
Size const new_capacity = 2*storage_.top().v.size();
clog << "| adding new vector with capacity " <<
new_capacity << "\n";
storage_.push( {} );
storage_.top().v.reserve( new_capacity ); // Raw
allocation.
}
 
vector<Item_storage>& v = storage_.top().v;
v.emplace_back( tag::Do_nothing{} ); // Hopefully
this is fast.
clog << "| using vector item " << &v.back() << "\n";
return {reinterpret_cast<Item*>( &v.back() )};
}
 
Fixed_size_allocator()
{
storage_.push( {} );
storage_.top().v.reserve( 1 ); // Or some higher
initial capacity.
}
};
} // namespace my
 
template< class Item >
auto operator new( size_t const size, my::Fixed_size_allocator<Item>& a )
-> void*
{ return a.allocate().value; }
 
#include <iostream>
using namespace std;
auto main()
-> int
{
using namespace my;
 
Fixed_size_allocator<int> fsa;
vector<int*> v;
for( int i = 0; i < 10; ++i )
{
cout << i << endl;
v.push_back( new( fsa ) int{ i } );
}
for( int* const p : v )
{
cout << *p << " ";
}
cout << endl;
}
 
 
I suggest you just wrap your container (of key->pointer pairs) together
with a Fixed_size_allocater, in a suitable little wrapper class.
 
To destroy non-POD items you can call the destructor of the item, then
if necessary deallocate its storage (add it to the free list).
 
 
Cheers & hth., + maybe a little challence :),
 
- Alf
"Christopher J. Pisz" <cpisz@austin.rr.com>: Mar 13 10:56PM -0500

Can someone verify I implemented the C++11 move constructor and move
assignment operators correctly in a few classes?
 
I just updated
https://github.com/ChristopherPisz/ECommerce/tree/master/Domain
 
If someone could look at Customer and Order classes there (they are
pretty simplistic)
 
I am still getting used to using C++11 since past jobs didn't use modern
compilers. I think I am getting the hang of it, but want to make sure.
 
 
Copying here for the newsgroup purists:
 
#pragma once
 
// Project Includes
#include "DomainLibrary.h"
 
// Boost Includes
#include <boost/optional.hpp>
 
// Standard Includes
#include <string>
 
//------------------------------------------------------------------------------
class DOMAIN_API Customer
{
public:
 
Customer(const unsigned int Id);
 
Customer(const unsigned int id
, const std::string & name
, const std::string & address
, const boost::optional<unsigned int> & age);
 
Customer(const Customer & rhs);
Customer(const Customer && rhs);
 
Customer & operator = (const Customer & rhs);
Customer & operator = (const Customer && rhs);
 
~Customer();
 
unsigned int GetId() const;
 
std::string GetName() const;
void SetName(const std::string & name);
 
std::string GetAddress() const;
void SetAddress(const std::string & address);
 
boost::optional<unsigned int> GetAge() const;
void SetAge(boost::optional<unsigned int> age);
 
protected:
 
unsigned int m_id; // Required
std::string m_name;
std::string m_address;
boost::optional<unsigned int> m_age; // Not set = DBNULL
};
 
 
 
// Project Includes
#include "Customer.h"
 
//------------------------------------------------------------------------------
Customer::Customer(const unsigned int id)
:
m_id(id)
{
}
 
//------------------------------------------------------------------------------
Customer::Customer(const unsigned int id
, const std::string & name
, const std::string & address
, const boost::optional<unsigned int> & age)
:
m_id (id)
, m_name (name)
, m_address(address)
, m_age ()
{
}
 
//------------------------------------------------------------------------------
Customer::Customer(const Customer & rhs)
:
m_id (rhs.m_id)
, m_name (rhs.m_name)
, m_address(rhs.m_address)
, m_age (rhs.m_age)
{
}
 
//------------------------------------------------------------------------------
Customer::Customer(const Customer && rhs)
:
m_id (rhs.m_id)
, m_name (rhs.m_name)
, m_address(rhs.m_address)
, m_age (std::move(rhs.m_age))
{
}
 
//------------------------------------------------------------------------------
Customer & Customer::operator = (const Customer & rhs)
{
if( this == &rhs )
{
return *this;
}
 
m_id = rhs.m_id;
m_name = rhs.m_name;
m_address = rhs.m_address;
m_age = rhs.m_age;
 
return *this;
}
 
//------------------------------------------------------------------------------
Customer & Customer::operator = (const Customer && rhs)
{
if( this == &rhs )
{
return *this;
}
 
m_id = rhs.m_id;
m_name = rhs.m_name;
m_address = rhs.m_address;
m_age = std::move(rhs.m_age);
 
return *this;
}
 
//------------------------------------------------------------------------------
Customer::~Customer()
{
}
 
//------------------------------------------------------------------------------
unsigned int Customer::GetId() const
{
return m_id;
}
 
//------------------------------------------------------------------------------
std::string Customer::GetName() const
{
return m_name;
}
 
//------------------------------------------------------------------------------
void Customer::SetName(const std::string & name)
{
m_name = name;
}
 
//------------------------------------------------------------------------------
std::string Customer::GetAddress() const
{
return m_address;
}
 
//------------------------------------------------------------------------------
void Customer::SetAddress(const std::string & address)
{
m_address = address;
}
 
//------------------------------------------------------------------------------
boost::optional<unsigned int> Customer::GetAge() const
{
return m_age;
}
 
//------------------------------------------------------------------------------
void Customer::SetAge(boost::optional<unsigned int> age)
{
m_age = age;
}
 
#pragma once
 
// Project Includes
#include "DomainLibrary.h"
#include "OrderItem.h"
 
// Standard Includes
#include <string>
#include <unordered_map>
#include <vector>
 
//------------------------------------------------------------------------------
class DOMAIN_API Order
{
public:
 
// Unordered Map is probably the best choice since we will be
removing by ID
//
// Key - Inventory Item ID
// Value - The OrderItem
typedef std::unordered_map<unsigned int, OrderItem> CollectionType;
 
enum OrderStatus
{
CREATED = 0
, ORDERED // We got paid
, READY_FOR_DELIVERY
, DELIVERED
, CANCELED
};
 
Order(const unsigned int id
, const unsigned int customerId);
 
Order(const unsigned int id
, const unsigned int customerId
, const CollectionType & orderItems);
 
Order(const Order & rhs);
Order(const Order && rhs);
 
Order & operator = (const Order & rhs);
Order & operator = (const Order && rhs);
 
virtual ~Order();
 
unsigned int GetId() const;
unsigned int GetCustomerId() const;
 
OrderStatus GetOrderStatus() const;
void SetOrderStatus(const OrderStatus orderStatus);
 
void AddOrderItem(const OrderItem & orderItem);
void RemoveOrderItem(unsigned int itemId);
 
CollectionType GetOrderItems() const;
void SetOrderItems(const CollectionType & orderItems);
 
protected:
 
unsigned int m_id;
unsigned int m_customerId;
 
OrderStatus m_status;
CollectionType m_orderItems;
};
 
 
// Project Includes
#include "Order.h"
 
// Standard Includes
#include <algorithm>
#include <iterator>
 
//------------------------------------------------------------------------------
Order::Order(const unsigned int id
, const unsigned int customerId)
:
m_id (id)
, m_customerId(customerId)
, m_status (CREATED)
{
}
 
//------------------------------------------------------------------------------
Order::Order(const unsigned int id
, const unsigned int customerId
, const CollectionType & orderItems)
:
m_id (id)
, m_customerId (customerId)
, m_status (CREATED)
, m_orderItems (orderItems)
{
}
 
//------------------------------------------------------------------------------
Order::Order(const Order & rhs)
:
m_id (rhs.m_id)
, m_customerId (rhs.m_customerId)
, m_status (rhs.m_status)
, m_orderItems (rhs.m_orderItems)
{
}
 
//------------------------------------------------------------------------------
Order::Order(const Order && rhs)
:
m_id (rhs.m_id)
, m_customerId(rhs.m_customerId)
, m_status (rhs.m_status)
{
std::move(rhs.m_orderItems.begin(), rhs.m_orderItems.end(),
std::inserter(m_orderItems, m_orderItems.begin()));
}
 
//------------------------------------------------------------------------------
Order & Order::operator = (const Order & rhs)
{
if( this == &rhs )
{
return *this;
}
 
m_id = rhs.m_id;
m_customerId = rhs.m_customerId;
m_status = rhs.m_status;
m_orderItems = rhs.m_orderItems;
 
return *this;
}
 
//------------------------------------------------------------------------------
Order & Order::operator = (const Order && rhs)
{
if( this == &rhs )
{
return *this;
}
 
m_id = rhs.m_id;
m_customerId = rhs.m_customerId;
m_status = rhs.m_status;
std::move(rhs.m_orderItems.begin(), rhs.m_orderItems.end(),
std::inserter(m_orderItems, m_orderItems.begin()));
 
return *this;
}
 
//------------------------------------------------------------------------------
Order::~Order()
{
}
 
//------------------------------------------------------------------------------
unsigned int Order::GetId() const
{
return m_id;
}
 
//------------------------------------------------------------------------------
unsigned int Order::GetCustomerId() const
{
return m_customerId;
}
 
//------------------------------------------------------------------------------
Order::OrderStatus Order::GetOrderStatus() const
{
return m_status;
}
 
//------------------------------------------------------------------------------
void Order::SetOrderStatus(const OrderStatus orderStatus)
{
m_status = orderStatus;
}
 
//------------------------------------------------------------------------------
void Order::AddOrderItem(const OrderItem & orderItem)
{
m_orderItems.insert(std::make_pair(orderItem.GetInventoryItemId(),
orderItem));
}
 
//------------------------------------------------------------------------------
void Order::RemoveOrderItem(unsigned int itemId)
{
m_orderItems.erase(itemId);
}
 
//------------------------------------------------------------------------------
Order::CollectionType Order::GetOrderItems() const
{
return m_orderItems;
}
 
//------------------------------------------------------------------------------
void Order::SetOrderItems(const CollectionType & orderItems)
{
m_orderItems = orderItems;
}
 
//------------------------------------------------------------------------------
Manfred <noname@invalid.add>: Mar 14 01:15PM +0100

On 3/14/2017 4:56 AM, Christopher J. Pisz wrote:
> Can someone verify I implemented the C++11 move constructor and move
> assignment operators correctly in a few classes?
 
I didn't check the details, but one thing that I saw is that move
assignment and constructors typically have non-const rhs arguments (they
may modify the rhs as they 'move' the value out of it)
Note that the standard allows for a X(const X&&) move constructor
(12.8.1 as it also allows for a X(X&) copy constructor) although its
example marks it as "OK, but possibly not sensible".
 
 
> Customer(const Customer & rhs);
> Customer(const Customer && rhs);
Customer(Customer && rhs);
 
> Customer & operator = (const Customer & rhs);
> Customer & operator = (const Customer && rhs);
Customer & operator = (Customer && rhs);
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 14 01:36PM +0100

On 14-Mar-17 4:56 AM, Christopher J. Pisz wrote:
 
>[snip]
> Copying here for the newsgroup purists:
 
[code snipped]
 
I tried a few times, some years ago, just attaching the code files, and
apparently that worked both technically and psychologically for all readers.
 
In Thunderbird those text file attachments appear as directly readable
text at the bottom of the message.
 
I am not sure, however, how well it works with archiving services, so I
think it's best to restrict it to supplementary information, e.g. "I've
attached the complete files so that readers can try this out".
 
 
Cheers!,
 
- Alf
scott@slp53.sl.home (Scott Lurndal): Mar 14 01:24PM


>[code snipped]
 
>I tried a few times, some years ago, just attaching the code files, and
>apparently that worked both technically and psychologically for all readers.
 
That's a broad statement, to be sure.
 
In fact, the NNTP client that I use doesn't handle attachments gracefully.
Paavo Helde <myfirstname@osa.pri.ee>: Mar 14 04:27PM +0200

On 14.03.2017 5:56, Christopher J. Pisz wrote:
> , m_name (rhs.m_name)
> , m_address(rhs.m_address)
> , m_age (std::move(rhs.m_age))
 
This does not call the boost::optional move constructor, because of the
'const'. Instead, it calls the standard copy constructor, which is
probably not what you intended.
 
Normally a user-defined move constructor should look like this:
 
Customer::Customer(Customer && rhs)
:
m_id (rhs.m_id)
, m_name (std::move(rhs.m_name))
, m_address(std::move(rhs.m_address))
, m_age (std::move(rhs.m_age))
{}
 
Ditto for other rvalue thingies.
 
Also, for such classes you do not actually need to write your own move
constructors or assignments at all. If you delete all your copy/move
constructors/assignments plus the destructor the compiler will generate
all this stuff by itself.
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 13 06:53PM -0700

What is the underlying reason why C++ prevents non-static member
functions from being called statically?
 
If they didn't reference member variables or things which require
a "this," or if they did so only under the scrutiny of discriminating
control flow logic, why would it be an issue? Why should it be
prevented?
 
Thank you,
Rick C. Hodgin
"Alf P. Steinbach" <alf.p.steinbach+usenet@gmail.com>: Mar 14 03:49AM +0100

On 14-Mar-17 2:53 AM, Rick C. Hodgin wrote:
> a "this," or if they did so only under the scrutiny of discriminating
> control flow logic, why would it be an issue? Why should it be
> prevented?
 
It's just the simplest rules.
 
There is nothing to be gained by adding rules that would allow a
non-this-accessing non-static member function to be called statically,
because that's the case of a member function that can be called both
statically and on an object, which is already covered by static member
functions: that's what should be used for this case.
 
E.g.
 
 
#include <iostream>
using namespace std;
 
struct S
{
static void foo() {}
};
 
auto main()
-> int
{
S::foo(); // static call
S{}.foo(); // call on an object, also OK.
}
 
 
Cheers & hth.,
 
- Alf
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 13 08:21PM -0700

On Monday, March 13, 2017 at 10:50:02 PM UTC-4, Alf P. Steinbach wrote:
> There is nothing to be gained by adding rules
 
It would be removing constraints, not adding rules.
 
> because that's the case of a member function that can be called both
> statically and on an object, which is already covered by static member
> functions: that's what should be used for this case.
 
class xyz
{
public:
xyz();
~xyz();
 
int abc(int a, int b, int c);
 
private:
static int k;
};
 
If I were to call xyz::abc(1, 0, 0), k would be in scope because
it's also static. But in addition, why couldn't an extension be
added to recognize I'm calling it from a static context, and then
possibly modify the dynamics by some runtime lookup?
 
int xyz::abc(int a, int b, int c)
{
// If called in a static context, use this block to perform
// a contextual lookup to derive the this member
static {
this = xyz::perform_some_lookup(a);
if (!this)
return -1; // No suitable context was found
}
 
// No longer static, runs with a proper context from here down
}
 
Thank you,
Rick C. Hodgin
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 13 08:37PM -0700

On Monday, March 13, 2017 at 11:21:58 PM UTC-4, Rick C. Hodgin wrote:
> }
 
> // No longer static, runs with a proper context from here down
> }
 
Such a context would be useful in an OS message handler, for example,
where messages are sent to a single function, but are intended for a
specific target, and the target isn't known until a lookup is performed
to identify the associated object from some list of things that the OS
could be responding to.
 
For Windows it could by the hwnd member that's used to identify the
particular window instance that's being updated, along with the class
related to processing that window.
 
In that case, the code could be modified:
 
LRESULT CALLBACK xyz::wndProc(HWND hwnd, UINT m, WPARAM w, LPARAM l)
{
static {
this = xyz::find_related_window(hwnd);
if (!this)
return DefWindowProc(hwnd, m, w, l);
}
 
// Now we have the correct class instance associated with this
// static callback from the OS. All members will be dynamically
// referenceable now.
}
 
Thank you,
Rick C. Hodgin
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 13 08:44PM -0700

On Monday, March 13, 2017 at 11:37:30 PM UTC-4, Rick C. Hodgin wrote:
> // static callback from the OS. All members will be dynamically
> // referenceable now.
> }
 
In addition, using a passed parameter to call a static reference as
for spawning a thread:
 
CreateThread(NULL, 0, &threadHandler, params, NULL, &params.threadId);
 
Dispatches to:
 
DWORD WINAPI xyz::threadHandler(LPVOID params)
{
// Re-establish our local class instance
static {
this = ((SParams*)params)->xyz;
}
 
// Now, the statically called member function is back in
// local scope, despite its necessary routing through the
// OS API for thread spawning and dispatching.
}
 
And there are many other such uses, where the dynamic instance can
be known, but it's just not known at the time of dispatch because
it requires some kind of lookup, or a re-establishing from a passed
parameter.
 
Thank you,
Rick C. Hodgin
Ian Collins <ian-news@hotmail.com>: Mar 14 05:07PM +1300

On 03/14/17 02:53 PM, Rick C. Hodgin wrote:
> a "this," or if they did so only under the scrutiny of discriminating
> control flow logic, why would it be an issue? Why should it be
> prevented?
 
Because there's no good reason not to make them static members?
 
How could the compiler tell if a non-inline member function behaved as
you describe?
 
If you really want to, you can lie to the compiler and do:
 
struct X
{
void f() {}
};
 
int main()
{
static_cast<X*>(nullptr)->f();
}
 
--
Ian
Jerry Stuckle <jstucklex@attglobal.net>: Mar 14 10:09AM -0400

On 3/13/2017 9:53 PM, Rick C. Hodgin wrote:
> prevented?
 
> Thank you,
> Rick C. Hodgin
 
If they didn't reference member variables or things which require a
"this", then why not declare them static?
 
As for control flow logic - that is run-time. The compiler cannot
predict the control flow logic would never let it occur.
 
--
==================
Remove the "x" from my email address
Jerry Stuckle
jstucklex@attglobal.net
==================
"Öö Tiib" <ootiib@hot.ee>: Mar 14 06:04AM -0700

On Monday, 13 March 2017 23:23:51 UTC+2, David Brown wrote:
 
> For non-integral members, you have to have a "constexpr const" to be
> able to initialise them inside the class definition, rather than outside
> it. I don't know why that is the case.
 
Is here any difference with just plain 'constexpr' (without 'const')?
 
I know that with pointers there is really difference so in following 'const'
matters:
 
static constexpr char const* abc = "abc text";
 
I always try to write const right of type (or *) since IMHO that makes
more clear that 'const' above is about 'char' but 'constexpr' is
about 'abc'.
However I don't think that this applies to array so isn't const about
constexpr array just redundant?
Ramine <toto@toto.net>: Mar 13 09:10PM -0400

Hello,
 
 
I will code for the following real-time OSs...
 
I will not code for VxwWorks real-time OS.
 
I will code in C++ and Delphi for the QNX real-time OS and
for One Time RTOS-32..
 
Here is QNX:
 
http://www.qnx.com/content/qnx/en.html
 
And here is One Time RTOS-32
 
http://www.on-time.com/rtos-32.htm
 
 
Thank you,
Amine Moulay Ramdane.
"Rick C. Hodgin" <rick.c.hodgin@gmail.com>: Mar 14 05:11AM -0700

On Monday, March 13, 2017 at 9:10:19 PM UTC-4, Ramine wrote:
> Hello,
> I will code for the following real-time OSs...
 
And then in the next post you say you will stop coding for real-time
OSs.
 
Can I suggest you gather your thoughts, write them down in a word
processor document, ponder them for a period of time (at least a
day or two, re-reading them after you've slept a time or two), and
then post only your final draft with your solid thoughts?
 
Thank you,
Rick C. Hodgin
Ramine <toto@toto.net>: Mar 13 10:32PM -0400

Hello,
 
I will stop coding for real-time systems..
 
I am an experienced programmer in parallel programming and
synchronization algorithms, i have invented many synchronization
algorithms , but you have to be aware that coding for real-time systems
is something different, because you have to ensure a very high standards
of quality, so it must be tested and retested and verified and
reverified with the right tools and the right prerequisites, so it
is not an easy job because real-time critical systems must be taken
seriously taking into account that safety is something
so so important, so i will not code for real-time critical systems
because to ensure a very high standards of quality we have to be
equipped with the necessary tools and the necessary prerequisites also
like being a group of high qualified programmers that code
for real-tiem systems to ensure a high quality of service
and high quality products, but my MemPool for real-time critical systems
is i think correct because i am an experienced programmer, but please
take a look at my code of my MemPool to be sure that all is well.
 
 
Thank you,
Amine Moulay Ramdane.
"Fred.Zwarts" <F.Zwarts@KVI.nl>: Mar 14 09:07AM +0100

"Ramine" schreef in bericht news:oa7kjg$nqj$5@dont-email.me...
>and high quality products, but my MemPool for real-time critical systems is
>i think correct because i am an experienced programmer, but please take a
>look at my code of my MemPool to be sure that all is well.
 
One sentence with 16 lines. I am impressed. Is that how you write your code,
too?
Ramine <toto@toto.net>: Mar 13 11:16PM -0400

Hello,
 
Selling faster to make more money..
 
Windows is not a real-time OS , so it has evolved fast because
also of selling faster to make more money , and thus it has come
with many bugs and with lower quality in the past..
 
But today the tools to code has become more sophisticated
and more efficient and smart and efficient reusability also has enhanced
the quality of software services and software products, so today we are
better equipped to be better satisfied, that's the reality
of today. Past was the past, and today is today.
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <toto@toto.net>: Mar 13 11:02PM -0400

Hello,
 
We have to be smart..
 
Real-time coding and Real-time OSs don't evolve fast, because we have to
ensure a very high standards of quality and safety.
 
Standards also like C++ don't evolve fast also, because making standards
takes time.
 
But Windows is not a real-time OS. so it has evolved fast and has come
with many bugs.
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <toto@toto.net>: Mar 13 10:47PM -0400

Hello......
 
About coding for real-time systems..
 
Using bounded stacks and queues to ensure determinism, i know how to do
it with my MemPool for real-time systems, and i have invented also
many synchronization algorithms and i am an experienced programmer, but
the problem of coding for real-time systems is not coding individually
with just more exprerience at hand, it is coding with the right
tools and the right prerequisites , and among the prerequisites
is to be a group or better being a bigger group of high qualified
programmers(like being Intel or Microsoft) that do the coding for
real-time systems to ensure a high quality of service and high quality
products that are mandatory for coding for real-time systems.
 
Thank you,
Amine Moulay Ramdane.
Ramine <toto@toto.net>: Mar 13 10:28PM -0400

Hello,
 
I will stop coding for real-time systems..
 
I am an experienced programmer in parallel programming and
synchronization algorithms, i have invented many synchronization
algorithms , but you have to be aware that coding for real-time systems
is something different, because you have to ensure a very high standards
of quality, so it must be tested and retested and verified and
reverified with the right tools and the right prerequisites, so it
is not an easy job because real-time critical systems must be taking
seriously taking into account that safety is something
so so important, so i will not code for real-time critical systems
because to ensure a very high standards of quality we have to be
equipped with the necessary tools and the necessary prerequisites also
like being a group of high qualified programmers that code
for real-tiem systems to ensure a high quality of service
and high quality products, but my MemPool for real-time critical systems
is i think correct because i am an experienced programmer, but please
take a look at my code of my MemPool to be sure that all is well.
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <toto@toto.net>: Mar 13 09:02PM -0400

Hello,
 
 
About real-time OSs..
 
Here is a small comparison about the two best:
 
QNX is a memory protected micro kernel OS, which means your programs run
in their own memory space chances of one stamping on another's memory is
zero.
 
VxWorks does not segregate kernel and user memory space, thereby
providing the fastest communication between applications and kernel but
there is still a danger of memory corruption.
 
 
 
Thank you,
Amine Moulay Ramdane.
Ramine <toto@toto.net>: Mar 13 07:51PM -0400

Hello..
 
My C++ MemPool for real-time systems was updated to version 1.01
 
I have tested it more with a memory leak detector and stabilized it
more, and i think it is correct now.
 
You can download the updated version from:
 
https://sites.google.com/site/aminer68/c-mempool-for-real-time-systems
 
 
Thank you,
Amine Moulay Ramdane.
You received this digest because you're subscribed to updates for this group. You can change your settings on the group membership page.
To unsubscribe from this group and stop receiving emails from it send an email to comp.lang.c+++unsubscribe@googlegroups.com.
Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)