diff --git a/buildlib/pyverbs_functions.cmake b/buildlib/pyverbs_functions.cmake
index 1966cf3ba1a3..6b272440a3d5 100644
--- a/buildlib/pyverbs_functions.cmake
+++ b/buildlib/pyverbs_functions.cmake
@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB)
-# Copyright (c) 2018, Mellanox Technologies. All rights reserved.  See COPYING file
+# Copyright (c) 2018 Mellanox Technologies, Inc. All rights reserved.  See COPYING file
 
 function(rdma_cython_module PY_MODULE)
   foreach(PYX_FILE ${ARGN})
diff --git a/pyverbs/CMakeLists.txt b/pyverbs/CMakeLists.txt
index 328263fcc739..79d87ec39a20 100644
--- a/pyverbs/CMakeLists.txt
+++ b/pyverbs/CMakeLists.txt
@@ -32,6 +32,11 @@ rdma_python_module(pyverbs/tests
   tests/utils.py
   )
 
+rdma_python_module(pyverbs/examples
+  examples/common.py
+  examples/ib_devices.py
+  )
+
 rdma_internal_binary(
   run_tests.py
   )
diff --git a/pyverbs/examples/__init__.py b/pyverbs/examples/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/pyverbs/examples/common.py b/pyverbs/examples/common.py
new file mode 100644
index 000000000000..f912ec85af70
--- /dev/null
+++ b/pyverbs/examples/common.py
@@ -0,0 +1,331 @@
+# SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB)
+# Copyright (c) 2019 Mellanox Technologies, Inc. All rights reserved. See COPYING file
+
+from _socket import SO_REUSEADDR, SOL_SOCKET
+from time import sleep
+import argparse
+import random
+import socket
+
+from pyverbs.pyverbs_error import PyverbsError, PyverbsUserError, \
+    PyverbsRDMAError
+from pyverbs.utils import wc_status_to_str
+from pyverbs.device import Context
+from pyverbs.pd import PD
+import pyverbs.enums as e
+
+MAX_ATTEMPTS = 5
+DATA_LENGTH = 1024
+
+
+class TCPData:
+    """
+    A wrapper class around the common data exchanged by ping-pong applications:
+    GID, LID, PSN and remote QPN. This class also provides a remote_data field
+    that can hold user-defined data.
+    """
+
+    def __init__(self, data=None):
+        self.extra_data = None
+        if data is None:
+            self.gid = None
+            self.lid = 0
+            self.qpn = 0
+            self.psn = random.getrandbits(24)
+        else:
+            remote_data = data.decode().split(',')
+            self.gid = remote_data[0]
+            self.lid = int(remote_data[1].strip())
+            self.qpn = int(remote_data[2].strip())
+            self.psn = int(remote_data[3].strip())
+            if len(remote_data) > 4:
+                self.extra_data = remote_data[4].strip()
+
+    def __str__(self):
+        ext = ''
+        if self.extra_data is not None:
+            ext = ', {ext}'.format(ext=self.extra_data)
+        return '{gid}, {lid}, {qpn}, {psn}{extra}'. \
+            format(gid=self.gid, lid=self.lid, qpn=self.qpn, psn=self.psn,
+                   extra=ext)
+
+
+class Common:
+    """
+    Base class for pyverbs-based applications. It provides basic args and
+    support for data exchange using TCPData
+    """
+
+    def __init__(self, logger=None):
+        """
+        Initializes a Common object.
+        :param logger: A logger object to use for prints
+        """
+        self.logger = logger
+        self.parser = argparse.ArgumentParser(
+            description='Parser for common examples options',
+            conflict_handler='resolve',
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+        self.parser.add_argument('-x', dest='server_name')
+        self.parser.add_argument('-d', '--device', default='mlx5_0',
+                                 help='IB device to use')
+        self.parser.add_argument('-i', '--ib-port', dest='ib_port', type=int,
+                                 default=1, help='Use <ib-port> of IB device')
+        self.parser.add_argument('-p', '--port', dest='tcp_port', type=int,
+                                 default=18515,
+                                 help='TCP port to exchange data over')
+        self.parser.add_argument('-s', '--size', dest='msg_size', type=int,
+                                 default=1024,
+                                 help='Size of message to exchange')
+        self.parser.add_argument('-r', '--rx-depth', dest='rx_depth', type=int,
+                                 default=1000)
+        self.parser.add_argument('-n', '--iters', dest='iters', type=int,
+                                 default=1000, help='Number of iterations')
+        self.tcp_data = TCPData()
+        self.remote_data = None
+        self.args = None
+
+    @property
+    def rlid(self):
+        return self.remote_data.lid
+
+    @property
+    def rgid(self):
+        return self.remote_data.gid
+
+    @property
+    def rqpn(self):
+        return self.remote_data.qpn
+
+    @property
+    def rpsn(self):
+        return self.remote_data.psn
+
+    def base_print(self, data):
+        """
+        Print the user-provided data into either the logger, if exists, or
+        to the shell. If logger exists, it is expected to have an 'info()'
+        method, similarly to the logger provided by Python's logging module.
+        :param data: Data to print
+        :return: None
+        """
+        if self.logger:
+            self.logger.info(data)
+        else:
+            print(data)
+
+    def print_stats(self, start, end):
+        """
+        Print execution statistics similarly to rdma-core's ping-pong examples.
+        Calling function should provide the start and end time as measured by
+        the application. Number of iterations is taken from the test's
+        arguments.
+        :param start: A datetime object representing the execution start time
+        :param end: A datetime object representing the execution end time
+        :return: None
+        """
+        time = end - start
+        total_us = time.seconds * 1000000 + time.microseconds
+        self.base_print('{iters} iters in {sec} seconds = {avg} usec/iter'.
+                        format(iters=self.args.iters, sec=total_us / 1000000,
+                               avg=total_us / self.args.iters))
+
+    def exchange_data(self, sync=False):
+        """
+        Sync or exchange data between two sides. Server side opens a socket
+        and listens while client side attempts to connect MAX_ATTEMPTS times
+        before failing.
+        :param sync: If True, only sync between the two sides, else perform
+                     data transfer as well.
+        :return: None
+        """
+
+        s = socket.socket()
+        s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
+        if self.args.server_name is None:
+            s.bind(('', self.args.tcp_port))
+            s.listen(5)
+            c, addr = s.accept()
+            if not sync:
+                remote_data = c.recv(DATA_LENGTH)
+                c.send(self.tcp_data.__str__().encode())
+                self.remote_data = TCPData(remote_data)
+        else:
+            attempts = 0
+            connected = False
+            while not connected:
+                try:
+                    s.connect((self.args.server_name, self.args.tcp_port))
+                    connected = True
+                except socket.error:
+                    attempts += 1
+                    if attempts > MAX_ATTEMPTS:
+                        raise PyverbsError(
+                            'Number of tries to connect socket exceeded')
+                    sleep(1)
+            if not sync:
+                s.send(self.tcp_data.__str__().encode())
+                remote_data = s.recv(DATA_LENGTH)
+                self.remote_data = TCPData(remote_data)
+        s.shutdown(socket.SHUT_RDWR)
+        s.close()
+
+
+class PingPong(Common):
+    """
+    Base class for pyverbs-based ping-pong applications. It provides a resource
+    initialization method (including querying port and GID if needed), data
+    validation, a wrapper around poll CQ and a basic check of the WC.
+    """
+
+    def __init__(self, logger=None):
+        """
+        Initializes a PingPong object.
+        :param logger: A logger object to use for prints
+        """
+        super(PingPong, self).__init__(logger)
+        self.context = None
+        self.recv_sg = None
+        self.add_grh = 0
+        self.args = None
+        self.pd = None
+        self.mr = None
+        self.num_cq_events = 0
+        self.parser.description = 'Parser for ping-pong common options'
+        self.parser.add_argument('-g', '--gid-index', dest='gid_index',
+                                 type=int, default=-1,
+                                 help='Source GID index')
+        self.parser.add_argument('-l', '--sl', dest='sl', type=int, default=0,
+                                 metavar='[0-15]', help='Service level value')
+        self.parser.add_argument('-v', '--data-validation',
+                                 action='store_true', dest='validate_data')
+
+    def query_port_attr(self):
+        """
+        Query port attributes for LID and whether or not GRH is required. GRH
+        is required in RoCE (as per spec) and in an environment which uses
+        GID-based addressing (such as IB SR-IOV).
+        This method provides early fail in case GRH is requires but GID index
+        was not provided by the user. An exception is raised in such case.
+        After calling this method, self.add_grh and self.tcp_data.lid will be
+        properly set.
+        :return: None
+        """
+        port_attr = self.context.query_port(self.args.ib_port)
+        grh_bit_set = port_attr.flags & e.IBV_QPF_GRH_REQUIRED
+
+        if grh_bit_set:
+            if self.args.gid_index == -1:
+                raise PyverbsUserError(
+                    'GRH is required but GID index was not provided')
+            self.add_grh = 1
+        self.tcp_data.lid = port_attr.lid
+
+    def set_gid(self):
+        self.tcp_data.gid =\
+            self.context.query_gid(self.args.ib_port,
+                                   self.args.gid_index).__str__()
+
+    def init_resources(self):
+        """
+        Create Context and use it to query port attributes and GID.
+        Port attributes are used to:
+        1. Check if GRH is required for this specific device.
+        2. Acquire LID.
+        GID and LID will later be exchanged in order to create a connection.
+        PD is also initialized in this method instead of in each inheriting
+        class.
+        :return: None
+        """
+        self.context = Context(name=self.args.device)
+        self.query_port_attr()
+        if self.add_grh:
+            self.set_gid()
+        self.pd = PD(self.context)
+
+    def execute(self):
+        """
+        A wrapper method to start execution properly: First initialize the
+        resources, then run.
+        :return: None
+        """
+        self.init_resources()
+        self.run()
+
+    def print_connection_details(self, is_local):
+        """
+        Print the local and remote connection details: GID, LID, QPN and PSN.
+        :param is_local: If True, print prefix will be 'Local data', else
+                         'Remote data'
+        :return: None
+        """
+        ext = ''
+        if self.tcp_data.extra_data is not None and is_local:
+            ext = 'Extra data: {e}'.format(e=self.tcp_data.extra_data)
+        if not is_local and self.remote_data.extra_data is not None:
+            ext = 'Extra data: {e}'.format(e=self.remote_data.extra_data)
+        if is_local:
+            self.base_print(
+                'Local data : GID: {gid} LID: {lid} QPN: {qpn} PSN: {psn} {ex}'.
+                format(gid=self.tcp_data.gid, lid=self.tcp_data.lid,
+                       qpn=self.tcp_data.qpn, psn=self.tcp_data.psn, ex=ext))
+        else:
+            self.base_print(
+                'Remote data: GID: {gid} LID: {lid} QPN: {qpn} PSN: {psn} {ex}'.
+                format(gid=self.rgid, lid=self.rlid, qpn=self.rqpn,
+                       psn=self.rpsn, ex=ext))
+
+    @staticmethod
+    def check_wc(wc):
+        """
+        Verify that the given work completion's status is success, else an
+        exception is raised.
+        :param wc: A WC object to check
+        :return: None
+        """
+        if wc.status != e.IBV_WC_SUCCESS:
+            raise PyverbsRDMAError('Completion status is {status}'.format(
+                status=wc_status_to_str(wc.status)))
+
+    def poll_cq(self, count):
+        """
+        Poll <count> completions from the CQ.
+        Note: This function calls the blocking poll() method of the CQ until
+        until <count> completions were received. Alternatively, gets a single
+        CQ event when events are used.
+        :param count: How many completions to poll
+        :return: An array of work completions of length <count>, None when
+                 events are used
+        """
+        if self.args.use_events:
+            if count > 1:
+                raise PyverbsUserError('Can\'t poll more than 1 CQE when using events')
+            self.cc.get_cq_event(self.cq)
+            self.num_cq_events += 1
+            self.cq.req_notify()
+        while count > 0:
+            nc, wcs = self.cq.poll(count)
+            for wc in wcs:
+                self.check_wc(wc)
+            count -= nc
+        return wcs
+
+    def validate(self, received_str):
+        """
+        Validate the received buffer against the expected result.
+        The application should set client's send buffer to 'c's and the
+        server's send buffer to 's's.
+        If the expected buffer is different than the actual, an exception will
+        be raised.
+        :param received_str: The received buffer to check
+        :return: None
+        """
+        expected_str = self.args.msg_size * ('c' if self.is_server else 's')
+        received_str = received_str.decode()
+        if received_str[0:self.args.msg_size] == \
+           expected_str[0:self.args.msg_size]:
+            return
+        else:
+            raise PyverbsError(
+                'Data validation failure: expected {exp}, received {rcv}'.
+                format(exp=expected_str, rcv=received_str))
diff --git a/pyverbs/utils.py b/pyverbs/utils.py
index a59d6275fefc..0126801eb02f 100644
--- a/pyverbs/utils.py
+++ b/pyverbs/utils.py
@@ -79,3 +79,22 @@ def mig_state_to_str(mig):
         return mig_states[mig]
     except KeyError:
         return 'Unknown ({m})'.format(m=mig)
+
+
+def wc_status_to_str(status):
+    try:
+        return \
+            {0: 'Success', 1: 'Local length error',
+             2: 'local QP operation error', 3: 'Local EEC operation error',
+             4: 'Local protection error', 5: 'WR flush error',
+             6: 'Memory window bind error', 7: 'Bad response error',
+             8: 'Local access error', 9: 'Remote invalidate request error',
+             10: 'Remote access error', 11: 'Remote operation error',
+             12: 'Retry exceeded', 13: 'RNR retry exceeded',
+             14: 'Local RDD violation error',
+             15: 'Remote invalidate RD request error',
+             16: 'Remote aort error', 17: 'Invalidate EECN error',
+             18: 'Invalidate EEC state error', 19: 'Fatal error',
+             20: 'Response timeout error', 21: 'General error'}[status]
+    except KeyError:
+        return 'Unknown WC status ({s})'.format(s=status)
