relational_operators/WorkOrder.hpp - incubator-retired-quickstep - Git at Google

 /**
  *   Copyright 2011-2015 Quickstep Technologies LLC.
  *   Copyright 2015 Pivotal Software, Inc.
  *
  *   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.
  **/

 #ifndef QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_
 #define QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_

 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <utility>
 #include <vector>

 #include "query_execution/QueryExecutionTypedefs.hpp"
 #include "utility/Macros.hpp"

 #include "glog/logging.h"

 #include "tmb/address.h"
 #include "tmb/id_typedefs.h"
 #include "tmb/message_bus.h"
 #include "tmb/message_style.h"
 #include "tmb/tagged_message.h"

 namespace quickstep {

 /** \addtogroup RelationalOperators
  *  @{
  */


 /**
  * @brief A single unit of work in a query plan, produced by a
  *        RelationalOperator. Where possible, WorkOrders should be of
  *        single-block granularity to maximize the opportunity for parallelism.
  **/
 class WorkOrder {
  public:
   /**
    * @brief Type of feedback message sent to relational operator.
    *
    * @note This is a per-operator type that is set and understood only by the
    *       relational operator.
    */
   typedef std::uint16_t FeedbackMessageType;

   /**
    * @brief Header struct used in feedback message.
    *
    * @note This is a per-operator type that is set and understood only by the
    *       relational operator.
    */
   struct FeedbackMessageHeader {
     std::size_t rel_op_index;
     std::size_t payload_size;
     FeedbackMessageType payload_type;

     /**
      * @brief Header constructor.
      * @param relational_op_index Index of the relation operator.
      * @param payload_size Size of the payload of the message.
      * @param payload_type Type of payload.
      */
     FeedbackMessageHeader(const std::size_t relational_op_index,
                           const std::size_t payload_size,
                           const FeedbackMessageType payload_type)
         : rel_op_index(relational_op_index),
           payload_size(payload_size),
           payload_type(payload_type) {}
   };

   /**
    * @brief A generic tagged message that can be sent from work order to
    *        relational operator.
    **/
   class FeedbackMessage {
    public:
     /**
      * @brief Feedback message constructor.
      *
      * @param type Type of the message.
      * @param rel_op_index Relational operator index.
      * @param payload Blob of payload.
      * @param payload_size Size of the payload blob.
      * @param ownership Whether to take ownership of the payload blob.
      */
     FeedbackMessage(const FeedbackMessageType type,
                     const std::size_t rel_op_index,
                     void *payload,
                     const std::size_t payload_size,
                     const bool ownership = true)
         : header_(rel_op_index, payload_size, type),
           payload_(payload),
           ownership_(ownership) {}

     /**
      * @brief Deserializing feedback message constructor.
      *
      * @param serialized_bytes Serialized byte stream of feedback message.
      * @param num_bytes Number of bytes in stream.
      * @param copy_payload Copy payload and take ownership.
      */
     FeedbackMessage(void *serialized_bytes,
                     const std::size_t num_bytes,
                     const bool copy_payload = false)
         : header_(*static_cast<const FeedbackMessageHeader *>(serialized_bytes)),
           ownership_(copy_payload) {
       CHECK_EQ(num_bytes, sizeof(header_) + header_.payload_size);
       if (copy_payload) {
         payload_ = static_cast<char *>(std::malloc(header_.payload_size));
         std::memcpy(payload_,
                     static_cast<const char *>(serialized_bytes) + sizeof(header_),
                     header_.payload_size);
       } else {
         payload_ = static_cast<char *>(serialized_bytes) + sizeof(header_);
       }
     }

     /**
      * @brief Move constructor.
      *
      * @param orig Message to be moved.
      */
     FeedbackMessage(FeedbackMessage &&orig)
         : header_(orig.header_),
           payload_(orig.payload_),
           ownership_(orig.ownership_) {
       orig.header_.payload_size = 0;
       orig.payload_ = nullptr;
     }

     /**
      * @brief Move assignment.
      *
      * @param orig Message to be moved.
      */
     FeedbackMessage& operator=(FeedbackMessage &&orig) {
       if (this != &orig) {
         if (ownership_) {
           std::free(payload_);
         }

         header_ = orig.header_;
         payload_ = orig.payload_;
         ownership_ = orig.ownership_;
         orig.payload_ = nullptr;
         orig.header_.payload_size = 0;
       }
       return *this;
     }

     /**
      * @brief Destructor.
      */
     virtual ~FeedbackMessage() {
       if (ownership_) {
         std::free(payload_);
       }
     }

     /**
      * @brief Serialize the feedback message into a byte stream.
      *
      * @return A pair containing the message stream and the message size.
      *
      * @note The caller is responsible for freeing the byte stream.
      */
     std::pair<void*, std::size_t> serializeMessage() const {
       char *msg = static_cast<char *>(
           std::malloc(sizeof(header_) + header_.payload_size));
       CHECK(nullptr != msg) << "Unable to allocate byte stream.";
       std::memcpy(msg, &header_, sizeof(header_));
       std::memcpy(msg + sizeof(header_), payload_, header_.payload_size);
       return std::make_pair(msg, sizeof(header_) + header_.payload_size);
     }

     /**
      * @brief Message type accessor.
      */
     FeedbackMessageType type() const { return header_.payload_type; }

     /**
      * @brief Header accessor.
      */
     const FeedbackMessageHeader& header() const { return header_; }

     /**
      * @brief Payload accessor.
      */
     const void* payload() const { return payload_; }

     /**
      * @brief Payload size accessor.
      */
     std::size_t payload_size() const { return header_.payload_size; }

     /**
      * @brief Ownership.
      */
     bool ownership() const { return ownership_; }

     /**
      * @brief Drop ownership.
      *
      * @note The entity calling this should take responsibility of freeing the
      * payload.
      */
     void dropOwnership() {
       ownership_ = false;
     }

    private:
     FeedbackMessageHeader header_;
     void* payload_;
     bool ownership_;

     DISALLOW_COPY_AND_ASSIGN(FeedbackMessage);
   };

   /**
    * @brief Virtual destructor.
    **/
   virtual ~WorkOrder() {}

   /**
    * @brief Run this WorkOrder in the calling thread.
    **/
   virtual void execute() = 0;

   /**
    * @brief Get the preferred NUMA node(s) where this WorkOrder should be
    *        executed.
    *
    * @return A vector of preferred NUMA nodes. An empty vector indicates that
    *         the WorkOrder can be executed on any NUMA node.
    **/
   const std::vector<int>& getPreferredNUMANodes() const {
     return preferred_numa_nodes_;
   }

   /**
    * @brief Send message to relational operator.
    *
    * @param bus A pointer to the TMB.
    * @param sender_id The client ID of the sender.
    * @param receiver_id The client ID of the receiver.
    * @param feedback_msg Feedback message to be sent to relational operator.
    **/
   static void SendFeedbackMessage(tmb::MessageBus *bus,
                                   tmb::client_id sender_id,
                                   tmb::client_id receiver_id,
                                   const FeedbackMessage &feedback_msg) {
     std::pair<void *, std::size_t> stream = feedback_msg.serializeMessage();

     tmb::TaggedMessage msg;
     msg.acquire_message(stream.first, stream.second, kWorkOrderFeedbackMessage);

     tmb::Address receiver_address;
     receiver_address.AddRecipient(receiver_id);

     tmb::MessageStyle single_receiver_style;

     DCHECK(bus != nullptr);
     const tmb::MessageBus::SendStatus send_status =
         bus->Send(sender_id,
                   receiver_address,
                   single_receiver_style,
                   std::move(msg));
     CHECK(send_status == tmb::MessageBus::SendStatus::kOK) << "Message could"
         " not be sent from thread with TMB client ID " << sender_id << " to"
         " receiver thread with TMB client ID " << receiver_id;
   }

  protected:
   WorkOrder() {}

   // A vector of preferred NUMA node IDs where this workorder should be executed.
   // These node IDs typically indicate the NUMA node IDs of the input(s) of the
   // workorder. Derived classes should ensure that there are no duplicate entries
   // in this vector.
   std::vector<int> preferred_numa_nodes_;

  private:
   DISALLOW_COPY_AND_ASSIGN(WorkOrder);
 };

 /** @} */

 }  // namespace quickstep

 #endif  // QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_
	/**
	* Copyright 2011-2015 Quickstep Technologies LLC.
	* Copyright 2015 Pivotal Software, Inc.
	*
	* 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.
	**/

	#ifndef QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_
	#define QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_

	#include <cstddef>
	#include <cstdint>
	#include <cstdlib>
	#include <cstring>
	#include <utility>
	#include <vector>

	#include "query_execution/QueryExecutionTypedefs.hpp"
	#include "utility/Macros.hpp"

	#include "glog/logging.h"

	#include "tmb/address.h"
	#include "tmb/id_typedefs.h"
	#include "tmb/message_bus.h"
	#include "tmb/message_style.h"
	#include "tmb/tagged_message.h"

	namespace quickstep {

	/** \addtogroup RelationalOperators
	* @{
	*/


	/**
	* @brief A single unit of work in a query plan, produced by a
	* RelationalOperator. Where possible, WorkOrders should be of
	* single-block granularity to maximize the opportunity for parallelism.
	**/
	class WorkOrder {
	public:
	/**
	* @brief Type of feedback message sent to relational operator.
	*
	* @note This is a per-operator type that is set and understood only by the
	* relational operator.
	*/
	typedef std::uint16_t FeedbackMessageType;

	/**
	* @brief Header struct used in feedback message.
	*
	* @note This is a per-operator type that is set and understood only by the
	* relational operator.
	*/
	struct FeedbackMessageHeader {
	std::size_t rel_op_index;
	std::size_t payload_size;
	FeedbackMessageType payload_type;

	/**
	* @brief Header constructor.
	* @param relational_op_index Index of the relation operator.
	* @param payload_size Size of the payload of the message.
	* @param payload_type Type of payload.
	*/
	FeedbackMessageHeader(const std::size_t relational_op_index,
	const std::size_t payload_size,
	const FeedbackMessageType payload_type)
	: rel_op_index(relational_op_index),
	payload_size(payload_size),
	payload_type(payload_type) {}
	};

	/**
	* @brief A generic tagged message that can be sent from work order to
	* relational operator.
	**/
	class FeedbackMessage {
	public:
	/**
	* @brief Feedback message constructor.
	*
	* @param type Type of the message.
	* @param rel_op_index Relational operator index.
	* @param payload Blob of payload.
	* @param payload_size Size of the payload blob.
	* @param ownership Whether to take ownership of the payload blob.
	*/
	FeedbackMessage(const FeedbackMessageType type,
	const std::size_t rel_op_index,
	void *payload,
	const std::size_t payload_size,
	const bool ownership = true)
	: header_(rel_op_index, payload_size, type),
	payload_(payload),
	ownership_(ownership) {}

	/**
	* @brief Deserializing feedback message constructor.
	*
	* @param serialized_bytes Serialized byte stream of feedback message.
	* @param num_bytes Number of bytes in stream.
	* @param copy_payload Copy payload and take ownership.
	*/
	FeedbackMessage(void *serialized_bytes,
	const std::size_t num_bytes,
	const bool copy_payload = false)
	: header_(static_cast<const FeedbackMessageHeader >(serialized_bytes)),
	ownership_(copy_payload) {
	CHECK_EQ(num_bytes, sizeof(header_) + header_.payload_size);
	if (copy_payload) {
	payload_ = static_cast<char *>(std::malloc(header_.payload_size));
	std::memcpy(payload_,
	static_cast<const char *>(serialized_bytes) + sizeof(header_),
	header_.payload_size);
	} else {
	payload_ = static_cast<char *>(serialized_bytes) + sizeof(header_);
	}
	}

	/**
	* @brief Move constructor.
	*
	* @param orig Message to be moved.
	*/
	FeedbackMessage(FeedbackMessage &&orig)
	: header_(orig.header_),
	payload_(orig.payload_),
	ownership_(orig.ownership_) {
	orig.header_.payload_size = 0;
	orig.payload_ = nullptr;
	}

	/**
	* @brief Move assignment.
	*
	* @param orig Message to be moved.
	*/
	FeedbackMessage& operator=(FeedbackMessage &&orig) {
	if (this != &orig) {
	if (ownership_) {
	std::free(payload_);
	}

	header_ = orig.header_;
	payload_ = orig.payload_;
	ownership_ = orig.ownership_;
	orig.payload_ = nullptr;
	orig.header_.payload_size = 0;
	}
	return *this;
	}

	/**
	* @brief Destructor.
	*/
	virtual ~FeedbackMessage() {
	if (ownership_) {
	std::free(payload_);
	}
	}

	/**
	* @brief Serialize the feedback message into a byte stream.
	*
	* @return A pair containing the message stream and the message size.
	*
	* @note The caller is responsible for freeing the byte stream.
	*/
	std::pair<void*, std::size_t> serializeMessage() const {
	char msg = static_cast<char >(
	std::malloc(sizeof(header_) + header_.payload_size));
	CHECK(nullptr != msg) << "Unable to allocate byte stream.";
	std::memcpy(msg, &header_, sizeof(header_));
	std::memcpy(msg + sizeof(header_), payload_, header_.payload_size);
	return std::make_pair(msg, sizeof(header_) + header_.payload_size);
	}

	/**
	* @brief Message type accessor.
	*/
	FeedbackMessageType type() const { return header_.payload_type; }

	/**
	* @brief Header accessor.
	*/
	const FeedbackMessageHeader& header() const { return header_; }

	/**
	* @brief Payload accessor.
	*/
	const void* payload() const { return payload_; }

	/**
	* @brief Payload size accessor.
	*/
	std::size_t payload_size() const { return header_.payload_size; }

	/**
	* @brief Ownership.
	*/
	bool ownership() const { return ownership_; }

	/**
	* @brief Drop ownership.
	*
	* @note The entity calling this should take responsibility of freeing the
	* payload.
	*/
	void dropOwnership() {
	ownership_ = false;
	}

	private:
	FeedbackMessageHeader header_;
	void* payload_;
	bool ownership_;

	DISALLOW_COPY_AND_ASSIGN(FeedbackMessage);
	};

	/**
	* @brief Virtual destructor.
	**/
	virtual ~WorkOrder() {}

	/**
	* @brief Run this WorkOrder in the calling thread.
	**/
	virtual void execute() = 0;

	/**
	* @brief Get the preferred NUMA node(s) where this WorkOrder should be
	* executed.
	*
	* @return A vector of preferred NUMA nodes. An empty vector indicates that
	* the WorkOrder can be executed on any NUMA node.
	**/
	const std::vector<int>& getPreferredNUMANodes() const {
	return preferred_numa_nodes_;
	}

	/**
	* @brief Send message to relational operator.
	*
	* @param bus A pointer to the TMB.
	* @param sender_id The client ID of the sender.
	* @param receiver_id The client ID of the receiver.
	* @param feedback_msg Feedback message to be sent to relational operator.
	**/
	static void SendFeedbackMessage(tmb::MessageBus *bus,
	tmb::client_id sender_id,
	tmb::client_id receiver_id,
	const FeedbackMessage &feedback_msg) {
	std::pair<void *, std::size_t> stream = feedback_msg.serializeMessage();

	tmb::TaggedMessage msg;
	msg.acquire_message(stream.first, stream.second, kWorkOrderFeedbackMessage);

	tmb::Address receiver_address;
	receiver_address.AddRecipient(receiver_id);

	tmb::MessageStyle single_receiver_style;

	DCHECK(bus != nullptr);
	const tmb::MessageBus::SendStatus send_status =
	bus->Send(sender_id,
	receiver_address,
	single_receiver_style,
	std::move(msg));
	CHECK(send_status == tmb::MessageBus::SendStatus::kOK) << "Message could"
	" not be sent from thread with TMB client ID " << sender_id << " to"
	" receiver thread with TMB client ID " << receiver_id;
	}

	protected:
	WorkOrder() {}

	// A vector of preferred NUMA node IDs where this workorder should be executed.
	// These node IDs typically indicate the NUMA node IDs of the input(s) of the
	// workorder. Derived classes should ensure that there are no duplicate entries
	// in this vector.
	std::vector<int> preferred_numa_nodes_;

	private:
	DISALLOW_COPY_AND_ASSIGN(WorkOrder);
	};

	/** @} */

	} // namespace quickstep

	#endif // QUICKSTEP_RELATIONAL_OPERATORS_WORK_UNIT_HPP_