recordbatch.h

// Copyright 2018-2019 Delft University of Technology
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include <arrow/api.h>
#include <cerata/api.h>
#include <fletcher/common.h>
 
#include <utility>
#include <string>
#include <vector>
#include <memory>
 
#include "fletchgen/utils.h"
#include "fletchgen/basic_types.h"
#include "fletchgen/schema.h"
#include "fletchgen/bus.h"
 
namespace fletchgen {
 
using cerata::Port;
using cerata::Component;
using cerata::Instance;
using fletcher::Mode;
using cerata::default_domain;
 
struct FieldPort : public Port {
  enum Function {
    ARROW,      
    COMMAND,    
    UNLOCK      
  } function_;  
 
  std::shared_ptr<FletcherSchema> fletcher_schema_;
  std::shared_ptr<arrow::Field> field_;
  bool profile_ = false;
 
  FieldPort(std::string name,
            Function function,
            std::shared_ptr<arrow::Field> field,
            std::shared_ptr<FletcherSchema> fletcher_schema,
            std::shared_ptr<cerata::Type> type,
            Port::Dir dir,
            std::shared_ptr<ClockDomain> domain,
            bool profile)
      : Port(std::move(name), std::move(type), dir, std::move(domain)),
        function_(function),
        fletcher_schema_(std::move(fletcher_schema)),
        field_(std::move(field)),
        profile_(profile) {}
 
  std::shared_ptr<Object> Copy() const override;
};
 
std::shared_ptr<FieldPort> arrow_port(const std::shared_ptr<FletcherSchema> &fletcher_schema,
                                      const std::shared_ptr<arrow::Field> &field,
                                      bool reverse,
                                      const std::shared_ptr<ClockDomain> &domain = default_domain());
std::shared_ptr<FieldPort> command_port(const std::shared_ptr<FletcherSchema> &schema,
                                        const std::shared_ptr<arrow::Field> &field,
                                        const std::shared_ptr<Node> &index_width,
                                        const std::shared_ptr<Node> &tag_width,
                                        std::optional<std::shared_ptr<Node>> addr_width = std::nullopt,
                                        const std::shared_ptr<ClockDomain> &domain = default_domain());
 
std::shared_ptr<FieldPort> unlock_port(const std::shared_ptr<FletcherSchema> &schema,
                                       const std::shared_ptr<arrow::Field> &field,
                                       const std::shared_ptr<Node> &tag_width,
                                       const std::shared_ptr<ClockDomain> &domain = default_domain());
 
struct RecordBatch : public Component {
 public:
  RecordBatch(const std::string &name,
              const std::shared_ptr<FletcherSchema> &fletcher_schema,
              fletcher::RecordBatchDescription batch_desc);
  std::vector<std::shared_ptr<FieldPort>> GetFieldPorts(const std::optional<FieldPort::Function> &function = {}) const;
  fletcher::RecordBatchDescription batch_desc() const { return batch_desc_; }
  FletcherSchema *schema() { return fletcher_schema_.get(); }
  Mode mode() const { return mode_; }
 
 protected:
  void AddArrays(const std::shared_ptr<FletcherSchema> &fletcher_schema);
 
  std::vector<Instance *> array_instances_;
  std::shared_ptr<FletcherSchema> fletcher_schema_;
  Mode mode_ = Mode::READ;
  fletcher::RecordBatchDescription batch_desc_;
 
 private:
  void ConnectBusPorts(Instance *array, const std::string &prefix, cerata::NodeMap *rebinding);
};
 
std::shared_ptr<RecordBatch> record_batch(const std::string &name,
                                          const std::shared_ptr<FletcherSchema> &fletcher_schema,
                                          const fletcher::RecordBatchDescription &batch_desc);
 
}  // namespace fletchgen