commit code first

Author: majianzheng

Diff for: .gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.mvn
+*.iml
+.idea
+.vscode
+target
+build
+*.lock
+*.log

Diff for: Makefile

@@ -0,0 +1,51 @@
+#目标文件名
+TARGET:=libscm.so
+TARGET_TEST:=scm_test
+
+CC:= g++
+
+SRC=./src
+SRC_TEST=./test
+
+#头文件路径
+EXPORT_DIR=./export
+INCLUDE_DIR=${SRC}/include
+
+#输出路径
+BUILD_DIR=./build
+
+#头文件路径包含
+INC_DIR=-I${EXPORT_DIR} -I${INCLUDE_DIR} -I${SRC}
+INC_DIR_TEST=${INC_DIR} -I${SRC_TEST} -I${SRC_TEST}
+
+#编译的代码文件
+SOURCES=${SRC}/locks/*.cpp ${SRC}/concurrent/*.cpp ${SRC}/utils/*.cpp ${SRC}/memory/*.c
+SOURCES_TEST=${SRC_TEST}/*.cpp
+
+#链接的库
+LIB=-lpthread
+LIB_TEST=-L${BUILD_DIR} -lscm
+
+OPTIONS=-std=c++11 -Wall -g -fPIC
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${BUILD_DIR}
+
+all:
+	@echo "start build..."
+	@if [	!	-d $(BUILD_DIR)	];	then mkdir ${BUILD_DIR}; fi;
+	@${CC} ${OPTIONS} ${INC_DIR} -shared ${LIB} -o ${BUILD_DIR}/${TARGET} ${SOURCES}
+	@echo "build success!"
+
+.PHONY:test
+test:
+	@echo "start build the test source code..."
+	@${CC} ${OPTIONS} ${INC_DIR_TEST} ${LIB_TEST} -o ${BUILD_DIR}/${TARGET_TEST} ${SOURCES_TEST}
+	@echo "build test code success! start execute test..."
+	@${BUILD_DIR}/${TARGET_TEST}
+	@echo "test finished!"
+.PHONY:clean
+clean:
+	@if [	-d $(BUILD_DIR)	];	then rm -r -f ${BUILD_DIR}; fi;
+	@echo "cleaned up."
+
+

Diff for: README.md

@@ -0,0 +1,101 @@
+# simple c++ middleware
+
+As it's name, it's a light simple middleware library for c++ developers without any third library, and only for <code>Linux</code> and <code>MacOS</code> based raw OS kernal clang API and asm.
+
+* Memory pool
+* Lock based <code>AQS</code>
+* Blocking queue
+* Thread pool
+* High performance share memory management(todo).
+
+## Backgroud
+When we want to develop a small system, properly need depend on some third big library even if we only use a litle part of it.
+
+## Building and test
+
+Clean the old target. Use <code>make clean</code> command:
+```
+[root@localhost simple-cpp-middleware]# make clean
+cleaned up.
+```
+
+How to build it. Execute Makefile <code>make</code> command to build the library as:
+```
+[root@localhost simple-cpp-middleware]# make
+start build...
+build success!
+```
+
+Test it use the <code>make test</code> command like:
+
+```
+[root@localhost simple-cpp-middleware]# make test
+start build the test source code...
+build test code success! start execute test...
+test proccess is ready, start test>>>
+...
+...
+test result output
+...
+...
+test is over, press [Enter] to finish.
+
+test finished!
+```
+And also you can use group command once like <code>make clean all test</code>.
+```
+[root@localhost simple-cpp-middleware]# make clean all test
+cleaned up.
+start build...
+build success!
+start build the test source code...
+build test code success! start execute test...
+test proccess is ready, start test>>>
+...
+...
+test result output
+...
+...
+test is over, press [Enter] to finish.
+
+test finished!
+```
+
+## API document
+### Memory pool include the memory_pool.h
+```
+file: demo.c
+
+#include "memory_pool.h"
+
+int main(int argc, char const *argv[]) {
+    //At first alloc 10M space from system to init memory pool
+    mem_init(1024 * 1024 * 10);
+
+    //Malloc some memory from memory pool
+    void * buffer = mem_malloc(1024);
+
+    //Use the memory do something
+    const char* data = "some data...";
+    memcpy(buffer, data, strlen(data));
+
+    //At last release the memory
+    mem_free(buffer);
+
+    return 0;
+}
+```
+### Lock and thread usage
+```
+#include "ReentrantLock.h"
+#include "Thread.h"
+
+int main(int argc, char const *argv[]) {
+    //At first init a Lock instance.
+    ReentrantLock lock;
+
+    //Ant start a thread
+
+    return 0;
+}
+```

Diff for: export/Atomic.h

@@ -0,0 +1,65 @@
+
+
+#ifndef __SCM_ATOMIC_H__
+#define __SCM_ATOMIC_H__
+
+#include "scm.h"
+
+namespace SCM {
+
+//Atomic Virtual
+template<typename T>
+struct Atomic {
+    virtual void set(const T& t) = 0;
+
+    virtual T get() = 0;
+};
+
+class AtomicByte: public Atomic<unsigned char> {
+public:
+    virtual void set(const unsigned char& t);
+
+    virtual unsigned char get();
+};
+
+//INT16 Atomic
+class AtomicShort: public Atomic<short> {
+public:
+    virtual void set(const short& t);
+
+    virtual short get();
+
+    short incAndGet();
+
+    short getAndInc();
+};
+
+//INT32 Atomic
+class AtomicInt: public Atomic<int> {
+
+public:
+    virtual void set(const int& t);
+
+    virtual int get();
+
+    int incAndGet();
+
+    int getAndInc();
+};
+
+//INT64 Atomic
+class AtomicInt64: public Atomic<SCM_INT64> {
+public:
+    virtual void set(const SCM_INT64& t);
+
+    virtual SCM_INT64 get();
+
+    SCM_INT64 incAndGet();
+
+    SCM_INT64 getAndInc();
+};
+
+};
+
+
+#endif //__SCM_ATOMIC_H__

Diff for: export/BlockingQueue.h

@@ -0,0 +1,25 @@
+
+
+#ifndef _SCM_BLOCKING_QUEUE_H
+#define _SCM_BLOCKING_QUEUE_H
+
+#include "scm.h"
+
+namespace SCM {
+template<typename T>
+struct BlockingQueue {
+    virtual bool add(const T& e) = 0;
+
+    virtual bool offer(const T& e) = 0;
+
+    virtual void put(const T& e) = 0;
+
+    virtual bool offer(const T& e, const SCM_INT64& timeout) = 0;
+
+    virtual T take() = 0; 
+
+    virtual bool poll(T& d, const SCM_INT64& timeout) = 0;
+};
+}
+
+#endif

Diff for: export/LinkedBlockingQueue.h

@@ -0,0 +1,45 @@
+
+
+#ifndef _SCM_LINKED_BLOCKING_QUEUE_H
+#define _SCM_LINKED_BLOCKING_QUEUE_H
+
+#include "BlockingQueue.h"
+#include <list>
+
+namespace SCM {
+
+class Lock;
+class Condition;
+
+template<typename T>
+class LinkedBlockingQueue : public BlockingQueue<T> {
+private:
+    int _capacity;
+    Lock * _lock;
+    std::list<T> _queue;
+    Condition* _not_empty_cond;
+    Condition* _not_full_cond;
+    bool _not_empty_wait;
+    bool _not_full_wait;
+private:
+    bool is_full() const {return _queue.size() >= _capacity;}
+    bool is_empty() const {return _queue.empty();}
+public:
+    LinkedBlockingQueue(int capacity);
+    virtual ~LinkedBlockingQueue();
+
+    virtual bool add(const T& e) override;
+
+    virtual bool offer(const T& e) override;
+
+    virtual void put(const T& e) override;
+
+    virtual bool offer(const T& e, const SCM_INT64& timeout) override;
+
+    virtual T take() override; 
+
+    virtual bool poll(T& d, const SCM_INT64& timeout) override;
+};
+}
+
+#endif

Diff for: export/Lock.h

@@ -0,0 +1,49 @@
+/**
+ * A lock is a tool for controlling access to a shared resource by multiple threads.
+ * @author majianzheng
+ */
+
+#ifndef _SCM_LOCK_H
+#define _SCM_LOCK_H
+
+#include "scm.h"
+
+namespace SCM {
+struct Condition {
+    virtual void await() = 0;
+
+    virtual bool await(SCM_INT64 time) = 0;
+
+    virtual void signal() = 0;
+
+    virtual void signalAll() = 0;
+};
+
+
+struct Lock {
+    virtual void lock() = 0;
+
+    virtual bool tryLock(const SCM_INT64& time) = 0;
+
+    virtual void unlock() = 0;
+
+    virtual Condition* newCondition() = 0;
+};
+
+class ScopeLock {
+    private:
+    Lock* _lock;
+    public:
+    ScopeLock(Lock* lock) {
+        _lock = lock;
+        _lock->lock();
+    }
+    ~ScopeLock() {
+        _lock->unlock();
+    }
+};
+}
+//区域锁
+#define SCOPE_LOCK(lock_ptr) SCM::ScopeLock scope_lock(lock_ptr)
+
+#endif

Diff for: export/ReentrantLock.h

@@ -0,0 +1,28 @@
+/**
+ * A lock is a tool for controlling access to a shared resource by multiple threads.
+ * @author majianzheng
+ */
+
+#ifndef _SCM_REENTRANT_LOCK_H
+#define _SCM_REENTRANT_LOCK_H
+
+#include "Lock.h"
+
+namespace SCM
+{
+class ReentrantLock : public Lock {
+
+public:
+    virtual void lock() override;
+
+    virtual bool tryLock(const SCM_INT64 &time) override;
+
+    virtual void unlock() override;
+
+    virtual Condition *newCondition() override;
+};
+} // namespace SCM
+
+
+
+#endif