Please consider the following formatting changes to #15901

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h

@@ -26,6 +26,11 @@
 #include "ITStracking/LineProjection.h"
 #include "DetectorsBase/Propagator.h"
 
+namespace o2::itsmft::tracking
+{
+class ExternalAllocator;
+}
+
 namespace o2::its
 {
 using o2::itsmft::tracking::bounded_vector;
@@ -41,7 +46,7 @@ template <int>
 class IndexTableUtils;
 class Cluster;
 class TrackITSExt;
-class ExternalAllocator;
+using ExternalAllocator = o2::itsmft::tracking::ExternalAllocator;
 
 template <int NLayers>
 struct TrackingKernels {

Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h

@@ -16,72 +16,13 @@
 #ifndef TRACKINGITSU_INCLUDE_EXTERNALALLOCATOR_H_
 #define TRACKINGITSU_INCLUDE_EXTERNALALLOCATOR_H_
 
-#include <memory_resource>
 #include "GPUO2ExternalUser.h"
-#include "Base/GPUMemoryResource.h"
+#include "ITSMFTTracking/ExternalAllocator.h"
 
 namespace o2::its
 {
-
-class ExternalAllocator
-{
-  using Type = std::underlying_type_t<o2::gpu::GPUMemoryResource::MemoryType>;
-
- public:
-  virtual void deallocate(char*, size_t) = 0;
-  virtual void* allocate(size_t) = 0;
-  void* allocate(size_t s, Type type)
-  {
-    auto old = mType;
-    mType = type;
-    void* p = allocate(s);
-    mType = old;
-    return p;
-  }
-
-  void* allocateStack(size_t s)
-  {
-    return allocate(s, (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  }
-  virtual void pushTagOnStack(uint64_t) = 0;
-  virtual void popTagOffStack(uint64_t) = 0;
-
-  void setType(Type t) noexcept { mType = t; }
-  Type getType() const noexcept { return mType; }
-
- protected:
-  Type mType;
-};
-
-class ExternalAllocatorAdaptor final : public std::pmr::memory_resource
-{
- public:
-  explicit ExternalAllocatorAdaptor(ExternalAllocator* alloc) : mAlloc(alloc) {}
-
- protected:
-  void* do_allocate(size_t bytes, size_t alignment) override
-  {
-    void* p = mAlloc->allocate(bytes, o2::gpu::GPUMemoryResource::MemoryType::MEMORY_HOST);
-    if (!p) {
-      throw std::bad_alloc();
-    }
-    return p;
-  }
-
-  void do_deallocate(void* p, size_t bytes, size_t) override
-  {
-    mAlloc->deallocate(static_cast<char*>(p), bytes);
-  }
-
-  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
-  {
-    return this == &other;
-  }
-
- private:
-  ExternalAllocator* mAlloc;
-};
-
+using ExternalAllocator = o2::itsmft::tracking::ExternalAllocator;
+using ExternalAllocatorAdaptor = o2::itsmft::tracking::ExternalAllocatorAdaptor;
 } // namespace o2::its
 
 #endif

Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx

@@ -45,6 +45,9 @@ void TrackerDPL::init(InitContext& ic)
   mTimer.Reset();
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
   mChainITS.reset(mRecChain->AddChain<o2::gpu::GPUChainITS>());
+  if (mRecChain->Init()) {
+    throw std::runtime_error("GPU reconstruction initialization failed");
+  }
   mITSTrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
                                               mChainITS->GetITSTrackerTraits(),
                                               mChainITS->GetITSTimeframe());

Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/ExternalAllocator.h

@@ -0,0 +1,84 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file ExternalAllocator.h
+/// \brief
+///
+
+#ifndef ALICEO2_ITSMFT_TRACKING_EXTERNALALLOCATOR_H_
+#define ALICEO2_ITSMFT_TRACKING_EXTERNALALLOCATOR_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory_resource>
+#include <type_traits>
+#include "Base/GPUMemoryResource.h"
+
+namespace o2::itsmft::tracking
+{
+
+class ExternalAllocator
+{
+ public:
+  using Type = std::underlying_type_t<o2::gpu::GPUMemoryResource::MemoryType>;
+  virtual ~ExternalAllocator() = default;
+  virtual void deallocate(char*, size_t) = 0;
+  virtual void* allocate(size_t, Type) = 0;
+  void* allocate(size_t size) { return allocate(size, mType); }
+
+  void* allocateDevice(size_t size, bool stack)
+  {
+    return allocate(size, o2::gpu::GPUMemoryResource::MEMORY_GPU | (stack ? o2::gpu::GPUMemoryResource::MEMORY_STACK : 0));
+  }
+
+  void* allocateStack(size_t size) { return allocateDevice(size, true); }
+  virtual void pushTagOnStack(uint64_t) = 0;
+  virtual void popTagOffStack(uint64_t) = 0;
+
+  void setType(Type t) noexcept { mType = t; }
+  Type getType() const noexcept { return mType; }
+
+ protected:
+  Type mType{o2::gpu::GPUMemoryResource::MEMORY_HOST};
+};
+
+class ExternalAllocatorAdaptor final : public std::pmr::memory_resource
+{
+ public:
+  explicit ExternalAllocatorAdaptor(ExternalAllocator* alloc) : mAlloc(alloc) {}
+
+ protected:
+  void* do_allocate(size_t bytes, size_t alignment) override
+  {
+    void* p = mAlloc->allocate(bytes, o2::gpu::GPUMemoryResource::MemoryType::MEMORY_HOST);
+    if (!p) {
+      throw std::bad_alloc();
+    }
+    return p;
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t) override
+  {
+    mAlloc->deallocate(static_cast<char*>(p), bytes);
+  }
+
+  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
+  {
+    return this == &other;
+  }
+
+ private:
+  ExternalAllocator* mAlloc;
+};
+
+} // namespace o2::itsmft::tracking
+
+#endif

GPU/GPUTracking/Global/GPUChainITS.cxx

@@ -14,43 +14,44 @@
 
 #include "GPUChainITS.h"
 #include "GPUConstantMem.h"
+#include "GPUDefParametersConstants.h"
 #include "DataFormatsITS/TrackITS.h"
-#include "ITStracking/ExternalAllocator.h"
+#include "ITSMFTTracking/ExternalAllocator.h"
 #include "GPUReconstructionIncludesITS.h"
 
 using namespace o2::gpu;
 
-namespace o2::its
+namespace
 {
-class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
+class GPUFrameworkExternalAllocator final : public o2::itsmft::tracking::ExternalAllocator
 {
  public:
-  void* allocate(size_t size) final
+  explicit GPUFrameworkExternalAllocator(GPUReconstruction* fwr) : mFWReco(fwr) {}
+  void* allocate(size_t size, Type type) final
   {
-    return mFWReco->AllocateDirectMemory(size, mType);
+    return mFWReco->AllocateDirectMemory(size, type);
   }
-  void deallocate(char* ptr, size_t size) final {} // this is a simple no-op
-  void pushTagOnStack(uint64_t tag) final
-  {
-    mFWReco->PushNonPersistentMemory(tag);
-  }
-  void popTagOffStack(uint64_t tag) final
-  {
-    mFWReco->PopNonPersistentMemory(gpudatatypes::RecoStep::ITSTracking, tag);
-  }
-  void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
+  void deallocate(char*, size_t) final {}
+  void pushTagOnStack(uint64_t tag) final { mFWReco->PushNonPersistentMemory(tag); }
+  void popTagOffStack(uint64_t tag) final { mFWReco->PopNonPersistentMemory(gpudatatypes::RecoStep::ITSTracking, tag); }
 
  private:
-  o2::gpu::GPUReconstruction* mFWReco;
+  GPUReconstruction* mFWReco;
 };
-} // namespace o2::its
+} // namespace
 
 GPUChainITS::~GPUChainITS() = default;
 
 GPUChainITS::GPUChainITS(GPUReconstruction* rec) : GPUChain(rec) {}
 
 int32_t GPUChainITS::Init() { return 0; }
 
+void GPUChainITS::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
+{
+  gpuMem = constants::GPU_DEFAULT_MEMORY_SIZE;
+  pageLockedHostMem = constants::GPU_DEFAULT_HOST_MEMORY_SIZE;
+}
+
 o2::its::TrackerTraits<7>* GPUChainITS::GetITSTrackerTraits()
 {
   if (mITSTrackerTraits == nullptr) {
@@ -74,14 +75,20 @@ o2::its::TimeFrame<7>* GPUChainITS::GetITSTimeframe()
   }
 #if !defined(GPUCA_STANDALONE)
   if (mITSTimeFrame->isGPU()) {
-    mFrameworkAllocator.reset(new o2::its::GPUFrameworkExternalAllocator());
-    mFrameworkAllocator->setReconstructionFramework(rec());
-    mITSTimeFrame->setFrameworkAllocator(mFrameworkAllocator.get());
+    mITSTimeFrame->setFrameworkAllocator(GetITSMFTFrameworkAllocator());
   }
 #endif
   return mITSTimeFrame.get();
 }
 
+o2::itsmft::tracking::ExternalAllocator* GPUChainITS::GetITSMFTFrameworkAllocator()
+{
+  if (mFrameworkAllocator == nullptr && mRec->IsGPU()) {
+    mFrameworkAllocator = std::make_unique<GPUFrameworkExternalAllocator>(rec());
+  }
+  return mFrameworkAllocator.get();
+}
+
 int32_t GPUChainITS::PrepareEvent() { return 0; }
 
 int32_t GPUChainITS::Finalize() { return 0; }

GPU/GPUTracking/Global/GPUChainITS.h

@@ -21,8 +21,11 @@ namespace o2::its
 struct Cluster;
 struct TrackingFrameInfo;
 class TrackITSExt;
-class GPUFrameworkExternalAllocator;
 } // namespace o2::its
+namespace o2::itsmft::tracking
+{
+class ExternalAllocator;
+} // namespace o2::itsmft::tracking
 
 namespace o2::gpu
 {
@@ -39,15 +42,16 @@ class GPUChainITS final : public GPUChain
 
   void RegisterPermanentMemoryAndProcessors() final {};
   void RegisterGPUProcessors() final {};
-  void MemorySize(size_t&, size_t&) final {};
+  void MemorySize(size_t& gpuMem, size_t& pageLockedHostMem) final;
 
   o2::its::TrackerTraits<7>* GetITSTrackerTraits();
   o2::its::VertexerTraits<7>* GetITSVertexerTraits();
   o2::its::TimeFrame<7>* GetITSTimeframe();
+  o2::itsmft::tracking::ExternalAllocator* GetITSMFTFrameworkAllocator();
 
  protected:
   GPUChainITS(GPUReconstruction* rec);
-  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
+  std::unique_ptr<o2::itsmft::tracking::ExternalAllocator> mFrameworkAllocator;
   std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits<7>> mITSVertexerTraits;

GPU/GPUTracking/Interface/GPUO2Interface.cxx

@@ -261,6 +261,11 @@ void GPUO2Interface::setErrorCodeOutput(std::vector<std::array<uint32_t, 4>>* v)
   }
 }
 
+o2::itsmft::tracking::ExternalAllocator* GPUO2Interface::GetITSMFTFrameworkAllocator()
+{
+  return mChainITS->GetITSMFTFrameworkAllocator();
+}
+
 void GPUO2Interface::GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits<7>*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame)
 {
   trackerTraits = mChainITS->GetITSTrackerTraits();

GPU/GPUTracking/Interface/GPUO2Interface.h

@@ -45,6 +45,10 @@ class VertexerTraits;
 template <int>
 class TimeFrame;
 } // namespace o2::its
+namespace o2::itsmft::tracking
+{
+class ExternalAllocator;
+} // namespace o2::itsmft::tracking
 
 namespace o2::gpu
 {
@@ -78,6 +82,7 @@ class GPUO2Interface
   void DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data, uint32_t iThread, const char* dir = "");
   void DumpSettings(uint32_t iThread, const char* dir = "");
 
+  o2::itsmft::tracking::ExternalAllocator* GetITSMFTFrameworkAllocator();
   void GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits<7>*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame);
   const o2::base::Propagator* GetDeviceO2Propagator(int32_t iThread = 0) const;
   void UseGPUPolynomialFieldInPropagator(o2::base::Propagator* prop) const;