Introduce expression API (#4)

* Introduce expression API

Co-authored-by: Liubov Batanina  <[email protected]>

CMakeLists.txt

@@ -10,12 +10,6 @@ project(deepworks)
 ########################################
 set(CMAKE_CXX_STANDARD 17)
 
-########################################
-# Define include directories
-########################################
-set(COMMON_INCLUDES ${PROJECT_SOURCE_DIR}/include)
-include_directories(${COMMON_INCLUDES})
-
 ########################################
 # Define output paths
 ########################################

include/deepworks/deepworks.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <deepworks/placeholder.hpp>
+#include <deepworks/shape.hpp>
+#include <deepworks/tensor.hpp>

include/deepworks/placeholder.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <memory> // shared_ptr
+
+#include <deepworks/shape.hpp>
+
+namespace deepworks {
+
+class Call;
+class Placeholder {
+public:
+    explicit Placeholder(const deepworks::Shape& shape);
+
+    const Shape& shape() const;
+
+    // NB: Public for test, but not available for user,
+    // because Impl isn't exported to public API.
+    Placeholder(const deepworks::Shape& shape, Call call);
+    struct Impl;
+    const Impl& impl() const;
+    std::shared_ptr<Impl> m_impl;
+};
+
+} // namespace deepworks

include/deepworks/shape.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <vector>
+
+namespace deepworks {
+
+using Shape = std::vector<int>;
+
+} // namespace deepworks;

include/tensor.hpp → include/deepworks/tensor.hpp

@@ -3,9 +3,10 @@
 #include <vector>
 #include <memory>
 
+#include <deepworks/shape.hpp>
+
 namespace deepworks {
 
-using Shape = std::vector<int>;
 using Strides = std::vector<size_t>;
 
 class Tensor {

src/CMakeLists.txt

@@ -1,7 +1,19 @@
-file(GLOB SRC_FILES ${PROJECT_SOURCE_DIR}/src/*.cpp)
+set(SRC_FILES
+    ${CMAKE_CURRENT_LIST_DIR}/placeholder.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/call.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/tensor.cpp
+    )
+
+set(DeepWorks_INCLUDE_DIR "${PROJECT_SOURCE_DIR}/include/")
 
 add_library(${PROJECT_NAME} SHARED ${SRC_FILES})
 
+# Set public API
+target_include_directories(${PROJECT_NAME}
+                           PUBLIC ${DeepWorks_INCLUDE_DIR}
+                           PRIVATE "${PROJECT_NAME}/src"
+                          )
+
 if (WITH_EIGEN)
     find_package(Eigen3 3.3 REQUIRED NO_MODULE)
     target_link_libraries(${PROJECT_NAME} PRIVATE Eigen3::Eigen)

src/call.cpp

@@ -0,0 +1,20 @@
+#include <deepworks/placeholder.hpp>
+
+#include "call.hpp"
+#include "call_impl.hpp"
+
+deepworks::Call::Call(deepworks::LayerInfo&& info)
+    : m_impl(new Call::Impl{std::move(info)}) {
+}
+
+void deepworks::Call::pass(std::vector<deepworks::Placeholder>&& args) {
+    m_impl->args = std::move(args);
+}
+
+deepworks::Placeholder deepworks::Call::create(const deepworks::Shape& shape) {
+    return deepworks::Placeholder{shape, *this};
+};
+
+const deepworks::Call::Impl& deepworks::Call::impl() const {
+    return *m_impl;
+}

src/call.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <memory> // shared_ptr
+
+#include "layer_info.hpp"
+
+namespace deepworks {
+
+class Placeholder;
+struct Call {
+    Call() = default;
+    explicit Call(LayerInfo&&);
+
+    void pass(std::vector<Placeholder>&& args);
+
+    Placeholder create(const Shape& shape);
+
+    struct Impl;
+    const Impl& impl() const;
+    std::shared_ptr<Impl> m_impl;
+};
+
+} // namespace deepworks

src/call_impl.hpp

@@ -0,0 +1,10 @@
+#include "call.hpp"
+
+namespace deepworks {
+
+struct Call::Impl {
+    deepworks::LayerInfo     info;
+    std::vector<Placeholder> args;
+};
+
+} // namespace deepworks

src/layer_info.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace deepworks {
+
+struct LayerInfo {
+    std::string name;
+    std::string type;
+};
+
+} // namespace deepworks

src/placeholder.cpp

@@ -0,0 +1,21 @@
+#include <deepworks/placeholder.hpp>
+
+#include "call.hpp"
+#include "placeholder_impl.hpp"
+
+deepworks::Placeholder::Placeholder(const deepworks::Shape& shape,
+                                    deepworks::Call call)
+    : m_impl(new deepworks::Placeholder::Impl{shape, call}) {
+}
+
+deepworks::Placeholder::Placeholder(const deepworks::Shape& shape)
+    : m_impl(new deepworks::Placeholder::Impl{shape, {}}) {
+}
+
+const deepworks::Shape& deepworks::Placeholder::shape() const {
+    return m_impl->shape;
+}
+
+const deepworks::Placeholder::Impl& deepworks::Placeholder::impl() const {
+    return *m_impl;
+}

src/placeholder_impl.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <optional>
+
+#include "call.hpp"
+
+namespace deepworks {
+
+struct Placeholder::Impl {
+    deepworks::Shape shape;
+    // NB: The creator, empty optional if it's input.
+    std::optional<Call> call;
+};
+
+} // namespace deepworks

src/tensor.cpp

@@ -1,4 +1,5 @@
-#include <tensor.hpp>
+#include <deepworks/tensor.hpp>
+
 #include <numeric>
 #include <algorithm>
 

tests/unit/test_tensor.cpp

@@ -1,6 +1,6 @@
-#include <deepworks.hpp>
 #include <gtest/gtest.h>
-#include <tensor.hpp>
+
+#include <deepworks/tensor.hpp>
 
 TEST(TensorTest, Allocate) {
     deepworks::Tensor src_tensor;