Reverted std::weak_ptr<future_tile> back to SharedPtr<future_tile> in…

… DelayedTileFunctor: a TileFunctor must be able to deliver (future)tiles optimally as long as it exists.

clc/dll/include/CastedUnaryAttrOper.h

@@ -257,7 +257,7 @@ class CastedUnaryAttrSpecialFuncOperator : public AbstrCastedUnaryAttrOperator
 		auto arg1 = SharedPtr<const Arg1Type>(const_array_cast<Arg1Values>(arg1A));
 		dms_assert(arg1);
 
-		using prepare_data = std::shared_ptr<Arg1Type::future_tile>;
+		using prepare_data = SharedPtr<Arg1Type::future_tile>;
 
 		auto futureTileFunctor = make_unique_FutureTileFunctor<ResultValueType, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1](tile_id t) { return arg1->GetFutureTile(t); }

clc/dll/include/OperAttrBin.h

@@ -149,7 +149,7 @@ struct BinaryAttrOper : AbstrBinaryAttrOper
 		auto arg1 = SharedPtr<const Arg1Type>(const_array_cast<Arg1ValueType>(arg1A)); assert(arg1);
 		auto arg2 = SharedPtr<const Arg2Type>(const_array_cast<Arg2ValueType>(arg2A)); assert(arg2);
 
-		using prepare_data = std::pair<std::shared_ptr<typename Arg1Type::future_tile>, std::shared_ptr<typename Arg2Type::future_tile>>;
+		using prepare_data = std::pair<SharedPtr<typename Arg1Type::future_tile>, SharedPtr<typename Arg2Type::future_tile>>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<ResultValueType, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1, arg2, af](tile_id t) { return prepare_data{ arg1->GetFutureTile(af & AF1_ISPARAM ? 0 : t), arg2->GetFutureTile(af & AF2_ISPARAM ? 0 : t) }; }
 			, [this, af MG_DEBUG_ALLOCATOR_SRC_PARAM](sequence_traits<ResultValueType>::seq_t resData, prepare_data futureData)

clc/dll/include/OperAttrTer.h

@@ -156,7 +156,7 @@ struct TernaryAttrOper : AbstrTernaryAttrOper
 		auto arg2 = SharedPtr<const Arg2Type>(const_array_cast<Arg2ValueType>(arg2A)); assert(arg2);
 		auto arg3 = SharedPtr<const Arg3Type>(const_array_cast<Arg3ValueType>(arg3A)); assert(arg3);
 
-		using prepare_data = std::tuple<std::shared_ptr<typename Arg1Type::future_tile>, std::shared_ptr<typename Arg2Type::future_tile>, std::shared_ptr<typename Arg3Type::future_tile>>;
+		using prepare_data = std::tuple<SharedPtr<typename Arg1Type::future_tile>, SharedPtr<typename Arg2Type::future_tile>, SharedPtr<typename Arg3Type::future_tile>>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<ResultValueType, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1, arg2, arg3, af](tile_id t) { return prepare_data{ arg1->GetFutureTile(af & AF1_ISPARAM ? 0 : t), arg2->GetFutureTile(af & AF2_ISPARAM ? 0 : t), arg3->GetFutureTile(af & AF3_ISPARAM ? 0 : t) }; }
 			, [this, af MG_DEBUG_ALLOCATOR_SRC_PARAM](sequence_traits<ResultValueType>::seq_t resData, prepare_data futureData)

clc/dll/include/OperAttrUni.h

@@ -139,7 +139,7 @@ struct UnaryAttrOperator : AbstrUnaryAttrOperator
 
 		auto arg1 = SharedPtr<const Arg1Type>(const_array_cast<Arg1ValueType>(arg1A)); assert(arg1);
 
-		using prepare_data = std::shared_ptr<typename Arg1Type::future_tile>;
+		using prepare_data = SharedPtr<typename Arg1Type::future_tile>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<ResultValueType, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1, af](tile_id t) { return arg1->GetFutureTile(t); }
 			, [this, af MG_DEBUG_ALLOCATOR_SRC_PARAM](sequence_traits<ResultValueType>::seq_t resData, prepare_data futureData)

clc/dll/src1/RLookup.ipp

@@ -149,7 +149,7 @@ public:
 		auto arg1 = SharedPtr<const ArgumentType>(const_array_cast<V>(arg1A));
 		dms_assert(arg1);
 		auto indexBoxPtr = std::make_shared<std::any>(std::move(indexBox));
-		using prepare_data = std::shared_ptr<typename TileFunctor<V>::future_tile>;
+		using prepare_data = SharedPtr<typename TileFunctor<V>::future_tile>;
 		std::unique_ptr<AbstrDataObject> futureTileFunctor;
 
 		visit<typelists::domain_elements>(arg2DomainA

clc/dll/src1/lookup.cpp

@@ -187,7 +187,7 @@ class LookupOperator : public AbstrLookupOperator
 		auto valuesData = std::any_cast<typename DataArrayBase<V>::locked_cseq_t>(wrappedValuesArray);
 		dms_assert(valuesData);
 
-		using prepare_data = std::shared_ptr<typename Arg1Type::future_tile>;
+		using prepare_data = SharedPtr<typename Arg1Type::future_tile>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<V, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1](tile_id t) { return arg1->GetFutureTile(t); }
 			, [this, dcmArg1, actualIndexRange, valuesData  MG_DEBUG_ALLOCATOR_SRC_PARAM](sequence_traits<V>::seq_t resData, prepare_data futureData)

clc/dll/src2/OperConv.cpp

@@ -851,7 +851,7 @@ class TransformAttrOperator : public AbstrCastedUnaryAttrOperator
 		auto arg2 = SharedPtr<const Arg2Type>(debug_cast<const Arg2Type*>(argUnitA));
 		dms_assert(arg1);
 
-		using prepare_data = std::shared_ptr<Arg1Type::future_tile>;
+		using prepare_data = SharedPtr<Arg1Type::future_tile>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<TR, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1](tile_id t) { return arg1->GetFutureTile(t); }
 			, [arg2, arg1A](sequence_traits<TR>::seq_t resData, prepare_data arg1FutureData)
@@ -904,7 +904,7 @@ class ConvertAttrOperator : public AbstrCastedUnaryAttrOperator
 		auto arg2 = SharedPtr<const Arg2Type>(debug_cast<const Arg2Type*>(argUnitA));
 		dms_assert(arg1);
 
-		using prepare_data = std::shared_ptr<Arg1Type::future_tile>;
+		using prepare_data = SharedPtr<Arg1Type::future_tile>;
 		auto futureTileFunctor = make_unique_FutureTileFunctor<TR, prepare_data, false>(tileRangeData, get_range_ptr_of_valuesunit(valuesUnit), tileRangeData->GetNrTiles()
 			, [arg1](tile_id t) { return arg1->GetFutureTile(t); }
 			, [arg2, arg1A](sequence_traits<TR>::seq_t resData, prepare_data arg1FutureData)

tic/dll/src/AbstrDataObject.h

@@ -72,7 +72,7 @@ struct ptr : ptr_base<T, copyable>
 	explicit ptr(T* p) : ptr_base<T, copyable>( p ) {}
 };
 
-struct abstr_future_tile : std::enable_shared_from_this<abstr_future_tile>
+struct abstr_future_tile : TileBase
 {
 	virtual auto GetTileCRef() -> TileCRef = 0;
 };
@@ -103,7 +103,7 @@ class AbstrDataObject: public PersistentSharedObj
 	TIC_CALL tile_loc GetTiledLocation(row_id idx) const;
 
 // Abstr Tile retention
-	virtual auto GetFutureAbstrTile(tile_id t) const-> std::shared_ptr<abstr_future_tile> = 0;
+	virtual auto GetFutureAbstrTile(tile_id t) const-> SharedPtr<abstr_future_tile> = 0;
 	virtual auto GetReadableTileLock(tile_id t) const->TileCRef = 0; // TODO G8: REMOVE
 	virtual auto GetWritableTileLock(tile_id t, dms_rw_mode rwMode = dms_rw_mode::read_write)->TileRef = 0; // TODO G8: REMOVE
 

tic/dll/src/DataArray.cpp

@@ -70,7 +70,6 @@ granted by an additional written contract for support, assistance and/or develop
 //	Shadow creation 
 //----------------------------------------------------------------------
 
-TIC_CALL std::recursive_mutex s_CsFutureTileCreation;
 std::mutex s_mutableTileRecSection;
 
 template <typename V>

tic/dll/src/DataArray.h

@@ -137,8 +137,8 @@ struct DataArrayBase : AbstrDataObject
 		}
 	};
 
-	TICTOC_CALL virtual auto GetFutureTile(tile_id t) const -> std::shared_ptr<future_tile> = 0;
-	auto GetFutureAbstrTile(tile_id t) const -> std::shared_ptr<abstr_future_tile> override
+	TICTOC_CALL virtual auto GetFutureTile(tile_id t) const -> SharedPtr<future_tile> = 0;
+	auto GetFutureAbstrTile(tile_id t) const -> SharedPtr<abstr_future_tile> override
 	{
 		return GetFutureTile(t);
 	}
@@ -344,9 +344,9 @@ struct GeneratedTileFunctor : TileFunctor<V>
 		SharedPtr<const TileFunctor<V>> self;
 	};
 
-	auto GetFutureTile(tile_id t) const -> std::shared_ptr<future_tile> override
+	auto GetFutureTile(tile_id t) const -> SharedPtr<future_tile> override
 	{
-		return std::make_shared<future_caller>(t, this);
+		return new future_caller{t, this};
 	}
 };
 

tic/dll/src/TileFunctorImpl.h

@@ -48,23 +48,20 @@ granted by an additional written contract for support, assistance and/or develop
 #include "mem/TileData.h"
 #include "ser/VectorStream.h"
 
-TIC_CALL extern std::recursive_mutex s_CsFutureTileCreation;
-
 template <typename V>
 struct DelayedTileFunctor : TileFunctor<V>
 {
 	using future_tile = TileFunctor<V>::future_tile;
 	using locked_cseq_t = TileFunctor<V>::locked_cseq_t;
 
-	using cache_t = std::unique_ptr<std::weak_ptr<future_tile>[]>;
+	using cache_t = std::unique_ptr<SharedPtr<future_tile>[]>;
 	cache_t m_ActiveTiles;
 //	std::unique_ptr<std::mutex[]> m_Mutices;
 
 
 	DelayedTileFunctor(const AbstrTileRangeData* tiledDomainRangeData, range_data_ptr_or_void<field_of_t<V>> valueRangePtr, tile_id tn MG_DEBUG_ALLOCATOR_SRC_ARG)
 		: TileFunctor<V>(tiledDomainRangeData, valueRangePtr MG_DEBUG_ALLOCATOR_SRC_PARAM)
-		, m_ActiveTiles(std::make_unique<std::weak_ptr<future_tile>[]>(tn))
-//		, m_Mutices(std::make_unique<std::mutex[]>(tn))
+		, m_ActiveTiles(std::make_unique<SharedPtr<future_tile>[]>(tn))
 	{
 		MG_CHECK(tiledDomainRangeData);
 		MG_CHECK(tiledDomainRangeData->GetNrTiles() == tn);
@@ -74,26 +71,16 @@ struct DelayedTileFunctor : TileFunctor<V>
 		}
 	}
 
-	auto GetFutureTile(tile_id t) const -> std::shared_ptr<future_tile> override
+	auto GetFutureTile(tile_id t) const -> SharedPtr<future_tile> override
 	{
-		auto lockTileGeneration = std::lock_guard(s_CsFutureTileCreation);
-		auto result = m_ActiveTiles[t].lock();
-		if (!result)
-		{
-			result = CreateFutureTile(t);
-			m_ActiveTiles[t] = result;
-		}
-		return result;
+		return m_ActiveTiles[t];
 	}
 	auto GetTile(tile_id t) const->locked_cseq_t override
 	{
 		dms_assert(t < this->GetTiledRangeData()->GetNrTiles());
 
 		return GetFutureTile(t)->GetTile();
 	}
-
-	virtual auto CreateFutureTile(tile_id t) const -> std::shared_ptr<future_tile> = 0;
-
 };
 
 template <typename V, typename PrepareState, bool MustZero, typename PrepareFunc, typename ApplyFunc>
@@ -131,7 +118,7 @@ struct FutureTileFunctor : DelayedTileFunctor<V>
 				m_State.emplace<1>(std::move(resData));
 			}
 			dms_assert(m_State.index() == 1);
-			return locked_cseq_t(make_SharedThing(this->shared_from_this()), GetConstSeq(std::get<1>(m_State)));
+			return locked_cseq_t(this, GetConstSeq(std::get<1>(m_State)));
 		}
 		std::mutex  m_Mutex;
 		future_state m_State;
@@ -140,11 +127,6 @@ struct FutureTileFunctor : DelayedTileFunctor<V>
 #endif
 	};
 
-	auto CreateFutureTile(tile_id t) const -> std::shared_ptr<future_tile> override
-	{
-		return std::make_shared<tile_record>(pFunc(t), aFunc, this->m_TileRangeData->GetTileSize(t) MG_DEBUG_ALLOCATOR_SRC(md_SrcStr));
-	}
-
 	FutureTileFunctor(const AbstrTileRangeData* tiledDomainRangeData, range_data_ptr_or_void<field_of_t<V>> valueRangePtr, tile_id tn
 		, PrepareFunc&& pFunc_, ApplyFunc&& aFunc_ MG_DEBUG_ALLOCATOR_SRC_ARG)
 	: DelayedTileFunctor<V>(tiledDomainRangeData, valueRangePtr, tn MG_DEBUG_ALLOCATOR_SRC_PARAM)
@@ -155,6 +137,8 @@ struct FutureTileFunctor : DelayedTileFunctor<V>
 #endif
 	{
 		dms_assert(tn > 1);
+		for (tile_id t = 0; t != tn; ++t)
+			this->m_ActiveTiles[t] = new tile_record(pFunc(t), aFunc, tiledDomainRangeData->GetTileSize(t) MG_DEBUG_ALLOCATOR_SRC_PARAM);
 	}
 
 	PrepareFunc pFunc;

tic/dll/src/TreeItem.cpp

@@ -3753,6 +3753,10 @@ const TreeItem* FindTreeItemByID(const TreeItem* searchLoc, TokenID subItemID)
 //	InterestCount management
 //----------------------------------------------------------------------
 
+#include "DataArray.h"
+
+//mc_IntegrityCheckTiles
+
 #if defined(MG_DEBUG_DATASTORELOCK)
 UInt32 sd_ItemInterestCounter = 0;
 #endif
@@ -3771,15 +3775,8 @@ void TreeItem::StartInterest() const
 
 	SharedPtr<const TreeItem> refItem = GetReferredItem();
 
-//	dms_assert(IsCacheItem() || !IsDcKnown());
-
-//	MapExternalSourceHandle externalSourceHandle(this);
-//	dms_assert(IsCacheItem() || IsDcKnown() || !externalSourceHandle.m_Self);
-//	dms_assert(IsDcKnown() || !IsKnown());
-
 	SharedActorInterestPtr    calcHolder = mc_DC.get_ptr();
 	SharedTreeItemInterestPtr refItemHolder = refItem;
-//	SharedActorInterestPtr    checkerHolder = HasIntegrityChecker() ? GetIntegrityChecker() : nullptr;
 	SharedTreeItemInterestPtr parentHolder = GetTreeParent(); //  IsCacheItem() ? GetTreeParent() : nullptr;
 
 	Actor::StartInterest();
@@ -3795,12 +3792,8 @@ void TreeItem::StartInterest() const
 	}
 	// nothrow from here, avoid rollbacks and release the InterestHolders without releasing the interest
 	parentHolder.release();
-//	checkerHolder.release();
 	refItemHolder.release();
 	calcHolder.release();
-//	externalSourceHandle.m_Self = nullptr;
-//	dms_assert(!mc_Calculator || mc_Calculator->GetRefCount() == 1 && mc_Calculator->GetInterestCount() == 1);
-
 	unlockDsmUsageCounter.release();
 #if defined(MG_DEBUG_DATASTORELOCK)
 	++sd_ItemInterestCounter;

tic/dll/src/TreeItem.h

@@ -66,6 +66,7 @@ struct OperationContext;
 struct UsingCache;
 struct SupplCache;
 struct SourceLocation;
+
 class AbstrCalculator;
 using TreeItemList = single_linked_list<TreeItem>;